Ubuntu Repository: Total Packages and Sizes

Long time ago, I made a chart that shows Ubuntu Repositories’ size over several releases. At that time, there were only 6 releases and 1 release that was still being worked on. Fast forward almost 6 years later, now we have 18 Ubuntu releases, yay! How does that chart look like now?

Well, here we go! I just made some new charts!

Ubuntu Releases - Packages and SIzes

The full charts can be seen at http://fajran.github.io/vis-ubuntu-pkg/

As you can see, the repositories are constantly growing. Ubuntu starts with about 8 GB of packages and now it has more than 50 GB. The number of packages is also growing from just over 12.5 thousands and now it almost three times larger.

How did I count the numbers? I took the package index files (a.k.a. Packages file) and counted the number of packages inside. I also summed the size of each packages to get the size of the repository. The files are from the at-release repository which means I excluded the -updates and -security repositories. The at-release repository is presumably frozen and therefore the size won’t change anymore, where the latest two repositories are for the updates, which by definition are always updated. Well.. except when the release is not supported anymore.

I put all of the codes I wrote and use in my GitHub repository https://github.com/fajran/vis-ubuntu-pkg. Feel free to check, modify, and update it. I release the whole thing as public domain!

flickr browsr

Contoh aplikasi Kasuari yg lain: photo browser =D

Saya nyoba ngambil 800 foto di Flickr, lalu membuat kolase besar, dan menampilkannya dg Kasuari. Hasil akhir dapat dilihat di:

http://labs.fajran.web.id/p/kasuari/flickr/

Masing-masing foto berukuran 1024×860 pixel sehingga 800 foto berarti sekitar 557 megapixel. Foto-foto ini diambil dg bantuan Flickr API tuk search berdasar interestingness.

3.7 Gigapixel (v2)

Tulisan ini merupakan kelanjutan dari tulisan saya sebelumnya mengenai Kasuari, sebuah skrip untuk menampilkan gambar super besar dg teknik multi-scale pada halaman web dengan bantuan Javascript dan Canvas.

Saya baru saja menulis ulang skrip tersebut. Kali ini saya mematikan dulu fungsi pergerakan halus karena kok rasanya ngga terlalu menunjang sisi interaktivitas. Fungsi ini sebenarnya menunda pergerakan layar sehingga terlihat tidak menempel dengan pointer mouse. Karena penundaan ini, pergerakan terlihat “terlambat” dan tidak mengikuti pergerakan pointer mouse secara langsung. Penundaan ini mungkin bisa membuat pergerakan menjadi lebih “dinamis” dan tidak kaku tapi di lain pihak, pengguna bisa salah mengira kalau keterlambatan ini disebabkan oleh komputer yg lambat. Mungkin saya masih perlu bereksperimen dengan parameter2 yg ada.

Selain itu, saya juga menambahkan satu buah fitur baru, yaitu pembesaran halus. Saat mendekatkan atau menjauhkan gambar yg membuat gambar terlihat lebih besar dan kecil, transisi dilakukan secara bertahap. Dengan demikian, pengguna bisa mengikuti proses yang terjadi (yaitu pembesaran/pengecilan gambar) sehingga diharapkan pengguna tidak kehilangan konteks.

Saya juga menulis ulang aplikasi untuk mempersiapkan gambar yang akan dipakai oleh Kasuari. Awalnya aplikasi (yg saya tulis dg Python) ini hanya bisa menggunakan satu buah sumber gambar yang dijadikan gambar asli dalam resolusi penuh. Aplikasi akan memotong-motong gambar menjadi banyak gambar dengan ukuran lebih kecil (yaitu 256 × 256 piksel) dan lalu membuat gambar dalam skala (ukuran) yg lain dari gambar-gambar ini.

Kekurangan dari aplikasi ini adalah jika gambar berukuran sangat besar, bisa saja gambar disediakan dalam beberapa potongan gambar yang lebih kecil. Oleh karena itu, aplikasi harus dapat memproses beberapa gambar ini dalam menyusun gambar yang dibutuhkan oleh Kasuari.

Saya menggunakan pustaka Python Imaging Library (PIL) untuk membantu mengolah gambar. Namun ternyata PIL ini memiliki masalah jika gambar yang ditangani memiliki ukuran yang besar. PIL bekerja sangat lambat dan butuh memori sangat besar. Mungkin karena gambar yang ada perlu dimasukkan ke memori terlebih dahulu secara keseluruhan sebelum dapat diproses lebih lanjut. Berhubung proses pemotongan gambar dilakukan perbaris, seharusnya ada cara yang lebih cerdas untuk mengatasi masalah ini.

Akhirnya saya mencoba untuk menggunakan libjpeg untuk membuat aplikasi pemotong gambar. Walaupun akhirnya saya harus menulis kode dalam bahasa C, namun hasil akhirnya cukup memuaskan. Aplikasi yang saya tulis ini dapat bekerja dengan cepat dan menggunakan memori secukupnya.

Sebagai bahan uji coba, saya telah melanjutkan usaha gagal yang saya lakukan sebelumnya, yaitu mencoba menyediakan gambar berukuran 3.7 gigapixel dalam Kasuari. Gambar ini adalah peta dunia dari NASA yang memiliki resolusi 500m untuk setiap piksel yang ada. Ukuran gambar adalah 3.7 gigapixel (86400 × 43200) yang awalnya tersusun dari 8 buah gambar berukuran 21600 × 21600 piksel.

Hasil akhir dapat dilihat di http://labs.fajran.web.id/p/kasuari/bluemarble500m/ 🙂

Kode sumber Kasuari dan aplikasi pemotong gambar dapat dilihat di http://github.com/fajran/kasuari

3.7 Gigapixel

Itulah salah satu ukuran gambar peta dunia koleksi NASA BlueMarble. Dengan ukuran sebesar itu, satu piksel pada gambar sudah merepresentasikan sebuah area dengan luas 500×500 meter persegi.
Sungguh sangat menarik tuk ditampilkan dengan Kasuari. Langkah pertama yg saya harus lakukan tentu saja mendapatkan gambar tersebut.

Peta dunia dengan ukuran tersebut disajikan dalam dua versi. Versi pertama adalah 8 buah potong gambar yg harus disusun terlebih dahulu agar menjadi sebuah gambar utuh. Versi kedua (sepertinya) adalah gambar yang sudah utuh yang siap digunakan. Berhubung yang sudah jelas format gambarnya adalah yang versi pertama (tersedia dalam format JPEG dan PNG), saya coba mengunduh 8 buah gambar yg saya butuhkan.

Setelah gambar diunduh, tugas berikutnya adalah menggabungkan ke-delapan gambar tersebut menjadi satu gambar utuh. Setiap potongan gambar memiliki ukuran 21600×21600 piksel, alias sekitar 466 MP. Kalau 8 buah gambar tersebut digabung, maka ukuran akhir gambar adalah 86400×43200 piksel, alias sekitar 3.7 GP. Untuk urusan menggabungkan gambar seperti ini, saya mencoba menggunakan aplikasi montage dari ImageMagick.

Perintahnya sangat sederhana, yaitu seperti berikut ini.

$ montage {1,2,3,4,5,6,7,8}.jpg -tile 4x2 -geometry 21600 hasil.jpg

Daripada langsung menggabungkan 8 buah gambar tersebut sekaligus dalam sebuah perintah, saya tadi mencoba untuk menggabungkan setiap 2 gambar terlebih dahulu. Sehingga setelah tahap awal ini, saya memiliki 4 buah gambar dg ukuran 21600×43200 piksel. Setelah itu, saya coba gabungkan lagi 4 buah gambar tersebut menjadi satu gambar hasil yang saya harapkan.

Namun.. ternyata SISA KAPASITAS HARDDISK TIDAK CUKUP =)) Padahal sisa saat itu adalah sekitar 44GB (oya, saya make komputer di lab kampus). ImageMagick sudah cukup cerdas dg menggunakan harddisk sebagai media untuk meletakkan data sementara sehingga tidak seluruh pemrosesan dilakukan di RAM dari awal sampai akhir. Kalau tidak seperti ini, RAM 2GB yg ada mungkin sudah habis dan aplikasi tidak dapat bekerja banyak. Apa dikata ternyata harddisk yg tersisa jg tidak cukup T__T

Dengan demikian, upaya mendapatkan gambar 3.7 GP dg menggabungkan 8 buah gambar bisa dibilang gagal xD Langkah berikutnya adalah dg mencoba mengunduh gambar yg (sepertinya) sudah jadi. Ukuran berkasnya juga cukup (dan jauh) lebih besar, sampai 2.6GB.

Saya menghindari berkas yg satu ini berhubung ekstensi berkas yg dipakai tidak saya kenal. .bin.gz tidak menjelaskan sama sekali apa format berkas tersebut. Berkas readme yang ada sebenarnya sudah menyebut beberapa format, tapi tetap saja tidak ada yg saya kenal xD Daripada penasaran akhirnya saya coba unduh berkas tsb. Untungnya semua dilakukan di kampus, termasuk menggunakan koneksi internet kampus jadi saya gak perlu merelakan komputer saja tuk mengerjakan semua hal ini.

Setelah berkas tsb saya unduh dan ekstrak, saya coba gunakan file untuk mendeteksi format berkas tersebut. Namun.. file cuma bilang kalau berkas tsb adalah sebuah data T__T tetap tidak menjelaskan.. xD

Berhubung saya lg males nyobain aplikasi yg disebut di berkas readme tadi, maka saya hentikan dulu eksperimen menggunakan gambar 3.7 GP ini. Kayanya akan lbh menarik jika saya mikirin bagaimana cara lain untuk menyiapkan gambar bagi Kasuari dibanding nyari cara tuk mendapatkan satu buah gambar besar. Andai 8 gambar lbh kecil tadi bisa langsung digunakan, tentu saja akan lebih efisien.

Oh ya, dr tadi saya nyebut Kasuari, apa itu? Ya, itu nama burung di daerah irian sana. Tapi itu jg adalah nama proyek iseng2 saya terbaru =D Silakan cek langsung di http://github.com/fajran/kasuari/.

Kasuari adalah sebuah penampil gambar dg teknik “multiscale”. Gambar yg sangat besar bisa ditampilkan pada layar yg kecil dengan cara menampilkannya dalam beberapa level detil. Persis sama dengan Google Maps yg bisa digunakan untuk menampilkan peta dunia. Euh, keduanya emang aplikasi sejenis. Begitu pula dengan Seadragon dan Seadragon AJAX dari Microsoft Live Labs.

Apa yang berbeda dengan yg lain? Kalau dari fitur, tentu saja Kasuari masih kalah jauh. Namun yang jelas, Kasuari itu open source sehingga bisa dioprek dan dipakai sesuka hati. Bukan hosted service seperti Google Maps sehingga bisa dipasang di mana saja. Kasuari juga cuma menggunakan javascript, css, dan HTML Canvas untuk melakukan semua hal ini. Ada produk open source sejenis, yaitu OpenZoom, namun OpenZoom ini menggunakan Flash.

Tuk ngeliat seperti apa Kasuari itu, silakan buka http://labs.fajran.web.id/p/kasuari/bluemarble/. Peta dunia dari NASA BlueMarble dengan ukuran lebih kecil (yaitu sekitar 233 MP) ditampilkan dengan Kasuari.

Using Prefuse through Jython

Prefuse is a very nice visualization toolkit. It is written in Java, it uses Java2D APIs to draw nodes, edges, and other visual items. It also handles events, supports animations, and other things you need to make the visualization become interactive.

The visualization display is implemented on top of JComponent. So it is very easy to embed it on another application, like what I did in LuaDeskSpot (source).

Okay, enough for the introduction. The purpose of this post is I want to show you how to use Prefuse through Jython. Yes, to make Prefuse (er.. Java, actually) scriptable!

  1. First, prepare the Jython installation.

    $ wget http://downloads.sourceforge.net/jython/jython_installer-2.5.0.jar
    $ java -jar jython_installer-2.5.0.jar
    
  2. Create Prefuse jar file. I have made one and you can freely use it.

    $ wget http://labs.fajran.web.id/p/ubuntu-pkg-vis/lib/prefuse.jar
    
  3. Set environment variables. The first one is path to Jython installation.

    $ export PATH=$PATH:/path/ke/lokasi/instalasi/jython
    

    Secondly, set JYTHONPATH so Jython can recognize the Prefuse library.

    $ export JYTHONPATH=$JYTHONPATH:prefuse.jar
    
  4. Make sure the setup is woking.

    $ jython
    >>> import prefuse
    

    If you get no error, then good! Prefuse has been set up properly. Then do whatever you want!

  5. I have made a Jython script that calls Prefuse. Check it out at http://gist.github.com/32288. Let’s try to use it as a demo.

    $ wget -O igv.py http://gist.github.com/raw/32288/503d011d94c564ffbdca91296b3fc204cf7b5186
  6. Now you have a Jython module called igv. It will handle the basic Prefuse initialization things. You just need to do the following to use it.

    $ jython
    >>> from igv import InteractiveGraphVisualization
    >>> ig = InteractiveGraphVisualization()
    

    That’s for the initialization and now let’s try to add some nodes and edges.

    >>> n1 = ig.add_node("satu")
    >>> n2 = ig.add_node("dua")
    >>> n3 = ig.add_node("tiga")
    >>> ig.add_edge(n1, n2)
    >>> ig.add_edge(n1, n3)
    >>> ig.add_edge(n2, n3)
    

And this is the obligatory screencast.

Have fun!

um.. yes, this is the translation of my previous blog entry discussing the same thing.

Using Prefuse through Jython

Prefuse is a very nice visualization toolkit. It is written in Java, it uses Java2D APIs to draw nodes, edges, and other visual items. It also handles events, supports animations, and other things you need to make the visualization become interactive.

The visualization display is implemented on top of JComponent. So it is very easy to embed it on another application, like what I did in LuaDeskSpot (source).

Okay, enough for the introduction. The purpose of this post is I want to show you how to use Prefuse through Jython. Yes, to make Prefuse (er.. Java, actually) scriptable!

  1. First, prepare the Jython installation.

    $ wget http://downloads.sourceforge.net/jython/jython_installer-2.5.0.jar
    $ java -jar jython_installer-2.5.0.jar
    
  2. Create Prefuse jar file. I have made one and you can freely use it.

    $ wget http://labs.fajran.web.id/p/ubuntu-pkg-vis/lib/prefuse.jar
    
  3. Set environment variables. The first one is path to Jython installation.

    $ export PATH=$PATH:/path/ke/lokasi/instalasi/jython
    

    Secondly, set JYTHONPATH so Jython can recognize the Prefuse library.

    $ export JYTHONPATH=$JYTHONPATH:prefuse.jar
    
  4. Make sure the setup is woking.

    $ jython
    >>> import prefuse
    

    If you get no error, then good! Prefuse has been set up properly. Then do whatever you want!

  5. I have made a Jython script that calls Prefuse. Check it out at http://gist.github.com/32288. Let’s try to use it as a demo.

    $ wget -O igv.py http://gist.github.com/raw/32288/503d011d94c564ffbdca91296b3fc204cf7b5186
  6. Now you have a Jython module called igv. It will handle the basic Prefuse initialization things. You just need to do the following to use it.

    $ jython
    >>> from igv import InteractiveGraphVisualization
    >>> ig = InteractiveGraphVisualization()
    

    That’s for the initialization and now let’s try to add some nodes and edges.

    >>> n1 = ig.add_node("satu")
    >>> n2 = ig.add_node("dua")
    >>> n3 = ig.add_node("tiga")
    >>> ig.add_edge(n1, n2)
    >>> ig.add_edge(n1, n3)
    >>> ig.add_edge(n2, n3)
    

And this is the obligatory screencast.

Have fun!

um.. yes, this is the translation of my previous blog entry discussing the same thing.

Augmented reality

Augmented reality adalah upaya untuk “menggabungkan” dunia nyata dan dunia virtual yg dibuat oleh komputer sehingga batas antara keduanya menjadi sangat tipis ([wikipedia](http://en.wikipedia.org/wiki/Augmented_reality)).

Barusan saya nemuin sebuah demo keren mengenai AR ini yang menggunakan nvidia tegra. Silakan intip video berikut.

Kalau mau nyoba langsung teknologi AR ini, coba juga kunjungi

Ngomong2 ttg [nvidia tegra](http://www.google.com/search?q=nvidia+tegra), kapan ya devicesnya pada bermunculan? *tak sabar*

Prefuse + Jython = Keren

English version of this post can be read at http://ngoprek.fajran.web.id/2009/07/using-prefuse-through-jython.html

Setelah semalem nyobain Jython, jadi kepikiran tuk make Prefuse dari Jython. Ternyata bisa! Utak-atik dikit lagi, dan jadilah sesuatu yg lebih menarik. Silakan lihat di screencast berikut =P

Kodingan bisa dilihat di http://gist.github.com/32288

Kalau mau nyoba:

  1. Download dan install Jython 2.5b0

    $ wget http://downloads.sourceforge.net/jython/jython_installer-2.5b0.jar
    $ java -jar jython_installer-2.5b0.jar
    

    Silakan atur sendiri lokasi instalasi.

  2. Download library prefuse.

    $ wget http://labs.fajran.web.id/p/ubuntu-pkg-vis/lib/prefuse.jar
    
  3. Atur environment variable

    $ export PATH=$PATH:/path/ke/lokasi/instalasi/jython
    $ export JYTHONPATH=$JYTHONPATH:prefuse.jar
    

    Pastikan kalo jalanin jython, muncul interactive shell-nya. Dan bisa ngejalanin yang berikut

    >>> import prefuse
    
  4. Download kodingan yg saya buat.

    $ wget -O igv.py http://gist.github.com/raw/32288/503d011d94c564ffbdca91296b3fc204cf7b5186
    
  5. Jalanin deh..

    $ jython
    >>> from igv import InteractiveGraphVisualization
    >>> ig = InteractiveGraphVisualization()
    
  6. Tambahin node dan edge

    >>> n1 = ig.add_node("satu")
    >>> n2 = ig.add_node("dua")
    >>> n3 = ig.add_node("tiga")
    >>> ig.add_edge(n1, n2)
    >>> ig.add_edge(n1, n3)
    >>> ig.add_edge(n2, n3)
    

Selamat menikmati =D