You will likely need these extensions:

[sourcecode language='cpp']
PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB;
PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;
PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;
PFNGLATTACHOBJECTARBPROC glAttachObjectARB;
PFNGLGETINFOLOGARBPROC glGetInfoLogARB;
PFNGLLINKPROGRAMARBPROC glLinkProgramARB;
PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;
PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB;
PFNGLUNIFORM1FARBPROC glUniform1fARB;
PFNGLUNIFORM1IARBPROC glUniform1iARB;
[/sourcecode]

Use something like GLee or GLEW or do it the way I explained in my last post. Next you need to load your shaders, compile them, attach them, link them and use them. Here is pretty much my code (which is pretty much from NeHe):

[sourcecode language='cpp']
void loadShader(char const *vs_filename, char const *ps_filename)
{
char *vertex_shader_source = NULL, *pixel_shader_source = NULL;

// reading shaders from file
vertex_shader_source = Helper::readFile(vs_filename);
pixel_shader_source = Helper::readFile(ps_filename);

GLuint shader_program, vertex_shader, pixel_shader;

shader_program = glCreateProgramObjectARB();
vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
pixel_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

glShaderSourceARB(vertex_shader, 1, (const GLcharARB**)&vertex_shader_source, NULL);
glShaderSourceARB(pixel_shader, 1, (const GLcharARB**)&pixel_shader_source, NULL);

glCompileShaderARB(vertex_shader);
glCompileShaderARB(pixel_shader);

glAttachObjectARB(shader_program, vertex_shader);
glAttachObjectARB(shader_program, pixel_shader);

glLinkProgramARB(shader_program);

glUseProgramObjectARB(shader_program);

delete [] vertex_shader_source;
delete [] pixel_shader_source;
}
[/sourcecode]

I suggest that you check for errors (caused much headache). glGetError() is your friend. Also take a look at the GLSL specification. For instance varying variables have to be declared both in the vertex and fragment shader.

The big achievement as of lately was to make VBOs work. VBOs or Vertex Buffer Objects allow to store the mesh data in the video memory (or wherever it is most performant). They are also called with few functions, thus eliminating the overhead of the immediate mode.

A downside however is that there is only one Index Buffer per VBO which means that you have to syncronize your data (vertices, vertex normals, texture coordinates). So you have store three vertices, three vertex normals and three texture coordinates for every triangle. A lot of redundancy but still a lot faster than the immediate mode.

Here is a (boring) screenshot (thanks again to aphlA for the sphere):

Needless to say that my .obj loader works now. \o/

I wish I would use a version control system, because I had a simple test implementation which would explain VBOs somewhat nicely but now I only have my fairly complex .obj loader. Sorry. I hope this is still somewhat understandable:

[sourcecode language='cpp']
void createTestBuffer(GLuint *v_buffer, GLuint *i_buffer, GLuint *vertex_count)
{
GLuint vert_buffer = 0;
GLuint index_buffer = 0;
// a simple plane:
GLfloat vertices[] = {
-1, -1, 0, // 0
-1, 1, 0, // 1
1, 1, 0, // 2
1, -1, 0 }; // 3
GLuint vert_size = 12;

// indexing the "vertices"
GLuint indices[] = {
0, 1, 2,
0, 2, 3 };
GLuint index_size = 6;

glGenBuffersARB(1, &vert_buffer);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vert_buffer);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, vert_size * sizeof(GLfloat), vertices, GL_STATIC_DRAW_ARB);

glGenBuffersARB(1, &index_buffer);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, index_buffer);
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, index_size * sizeof(GLuint), indices, GL_STATIC_DRAW_ARB);

*v_buffer = vert_buffer;
*i_buffer = index_buffer;
*vert_count = index_size; // number_of_tris * 3
}
[/sourcecode]

Rendering the VBO:

[sourcecode language='cpp']
void render()
{
// assume v_buffer, i_buffer and vert_count are global variables...
glBindBufferARB(GL_ARRAY_BUFFER_ARB, v_buffer);
glVertexPointer(3, GL_FLOAT, 0, (char*)NULL);

glEnableClientState(GL_VERTEX_ARRAY);

glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, i_buffer);
glDrawElements(GL_TRIANGLES, vert_count, GL_UNSIGNED_INT, 0);

glDisableClientState(GL_VERTEX_ARRAY);
}
[/sourcecode]

That's mostly from memory, so excuse any errors (or write a comment).

Menggunakan vertex array dapat mengurangi pemanggilan fungsi dan kelebihan shared vertices. Sayangnya, fungsi-fungsi vertex array berada pada sisi klien dan data pada array-array harus di kirim ulang ke server tiap kali ia dibutuhkan. Meskipun sebenarnya display list yang berada di sisi server takkan mengalami gangguan apapun atas pengiriman data yang berulang-ulang. Hanya saja, yang menjadi masalah adalah, ketika display list di-compile, data pada display list tidak dapat dimodifikasi.

Vertex Buffer Object (VBO) hadir untuk mengatasi masalah tersebut. VBO mengalokasikan buffer objects pada graphics memory untuk atribut vertex dan menyediakan beberapa fungsi sebagai akses ke array tersebut. Fungsi-fungsi tersebut digunakan di vertex arrays, seperti glVertexPointer(), glNormalPointer(), glTexCoordPointer(), dan lainnya. Data pada VBO dapat dibaca dan dimodifikasi dengan melakukan mapping buffer object ke dalam RAM. Kelebihan lain VBO adalah sharing buffer object dengan sejumlah klien seperti display list dan texture-texture. Karena VBO berada pada sisi server, maka multiple clients dapat mengakses buffer yang sama.

Memory manager pada VBO akan memilihkan posisi terbaik untuk buffer object di dalam memory berdasarkan parameter target dan usage. Sehingga memory manager dapat mengoptimalkan buffer-buffer dengan menyeimbangkan 3 jenis memory: system, AGP, dan video memory.
Langkah-langkah yang terdapat pada VBO:

1. Creating VBO
2. Drawing VBO
3. Updating VBO

Creating VBO
Pada bagian ini terdatap 3 langkah:

1. Generate a new buffer object dengan glGenBuffersARB().

glGenBuffersARB()
glGenBuffersARB() membangun buffer objects dengan identifier-nya sebagai return. Ia memiliki 2 parameter: yang pertama adalah jumlah buffer object yang dibangun, dan yang kedua adalah alamat dari array yang disimpan sebuah single ID ataupun multiple IDs.

void glGenBuffersARB(GLsizei n, GLuint* ids)

2. Bind the buffer object dengan glBindBufferARB().

glBindBufferARB()
glBindBufferARB() melakukan binding terhadap buffer object yang akan digunakan. Ia memiliki 2 parameter: target dan identifier.

void glBindBufferARB(GLenum target, GLuint id)

target adalah petunjuk untuk memberitahu VBO apakah buffer object digunakan untuk menyimpan vertex array data atau index array data: GL_ARRAY_BUFFER_ARB atau GL_ELEMENT_ARRAY_ARB.  Tiap atribut vertex, seperti vertex coordinates, texture coordinates, normals and color component arrays menggunakan GL_ARRAY_BUFFER_ARB. Index array yang digunakan untuk glDraw[Range]Elements() menggunakan GL_ELEMENT_ARRAY_BUFFER_ARB. Parameter target membantu VBO dalam menentukan posisi yang  paling efisien dari sebuah buffer object, sebagai contoh, beberapa sistem lebih memilih di AGP atau system memory, dan vertex-vertex di video memory.

Ketika glBindBufferARB() dipanggil, VBO memberikan 0 sebagai nilai awal buffer pada memory buffer.

3. Copy vertex data ke dalam buffer object dengan glBufferDataARB().

glBufferDataARB() berfungsi mengirim data ke dalam buffer object.

void glBufferDataARB(GLenum target, GLsizei size, const void* data, GLenum usage)

Sama seperti sebelumnya target dengan pilihan GL_ARRAY_BUFFER_ARB atau GL_ELEMENT_ARRAY_ARB. size adalah jumlah byte dari data yang akan dikirim. Parameter ketiga adalah pointer dari data array. Jika data adalah NULL pointer, maka VBO hanya menyediakan memory space dengan ukuran yang diberikan.  usage adalah petunjuk untuk VBO tentang tujuan menggunakan buffer object: static, dynamic, atau stream, dan read, copy atau draw.

Pilihan-pilihan untuk parameter usage:
GL_STATIC_DRAW_ARB
GL_STATIC_READ_ARB
GL_STATIC_COPY_ARB
GL_DYNAMIC_DRAW_ARB
GL_DYNAMIC_READ_ARB
GL_DYNAMIC_COPY_ARB
GL_STREAM_DRAW_ARB
GL_STREAM_READ_ARB
GL_STREAM_COPY_ARB

“static” berarti data di dalam VBO takkan diubah (ditentukan sekali dan digunakan berulang-ulang). “dynamic” berarti data akan diubah sewaktu-waktu (ditentukan dan digunakan berulang-ulang). “stream” berarti data akan berubah tiap frame (ditentukan sekali dan digunakan sekali).
“draw” berarti data akan dikirim ke GPU agar ditampilkan (aplikasi menuju GL). “read” berarti data akan dibaca oleh aplikasi klien (GL menuju aplikasi). “copy” berarti data akan digunakan untuk keduanya, ditampilkan dan dibaca (GL menuju GL).

VBO memory manager akan memilih tempat yang tepat untuk buffer object di dalam memory berdasarkan parameter usage yang dipilih. Sebagai contoh, GL_STATIC_DRAW_ARB dan GL_STREAM_DRAW_ARB mungkin menggunakan video memory, dan GL_DYNAMIC_DRAW_ARB mungkin menggunakan AGP memory. Tiap _READ_ buffer akan lebih baik bila ditempatkan di system ataupun AGP memory karena data akan lebih mudah diakses.

Beberapa fungsi lain pada VBO yang dapat digunakan adalah glBufferSubDataARB() dan glDeleteBuffersARB().

glBufferSubDataARB() juga digunakan untuk meng-copy data ke dalam VBO, sama seperti glBufferDataARB(). Bedanya, glBufferSubDataARB() hanya mengisi ulang data pada buffer yang telah tersedia, dengan starting point pada offset yang diberikan. Jadi glBufferSubDataARB() hanya dapat digunakan apabila kita sudah pernah memanggil glBufferDataARB().

void glBufferSubDataARB(GLenum target, GLint offset, GLsizei size, void* data)

glDeleteBuffersARB() digunakan untuk menghapus VBO. Setelah buffer object dihapus, semua content di dalamnya akan hilang.

void glDeleteBuffersARB(GLsizei size, GLuint* ids)

Secara keseluruhan code untuk creating VBO.

GLuint vboId;                              // ID of VBO
GLfloat* vertices = new GLfloat[vCount*3]; // create vertex array
...


// generate a new VBO and get the associated ID
glGenBuffersARB(1, &vboId);

// bind VBO in order to use
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboId);

// upload data to VBO
glBufferDataARB(GL_ARRAY_BUFFER_ARB, dataSize, vertices, GL_STATIC_DRAW_ARB);

// it is safe to delete after copying data to VBO
delete [] vertices;
...


// delete VBO when program terminated
glDeleteBuffersARB(1, &vboId);

Drawing VBO
Karena VBO berada di atas implementasi vertex array, maka rendering VBO hampir sama dengan menggunakan vertex array. Perbedaannya adalah pointer (yang sebelumnya ditujukan untuk vertex array) digunakan sebagai offset pada buffer object. Oleh karena itu tidak dibutuhkan tambahan API untuk menampilkan VBO kecuali glBindBufferARB().

// bind VBOs for vertex array and index array
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboId1);       // for vertex coordinates
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vboId2); // for indices

// do same as vertex array except pointer
glEnableClientState(GL_VERTEX_ARRAY);                 // activate vertex coords array
glVertexPointer(3, GL_FLOAT, 0, 0);                   // last param is offset, not ptr

// draw 6 quads using offset of index array
glDrawElements(GL_QUADS, 24, GL_UNSIGNED_BYTE, 0);

glDisableClientState(GL_VERTEX_ARRAY);             // deactivate vertex array

// bind with 0, so, switch back to normal pointer operation
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);   //switch off VBO operation

Updating VBO
Cara sederhana untuk mengubah data pada VBO adalah dengan meng-copy data baru ke dalam VBO dengan menggunakan glBufferDataARB() atau glBufferSubDataARB(). Tetapi ini berarti anda harus selalu menyediakan 2 data vertex: yang satu digunakan di aplikasi, yang satu lagi berada di VBO.

Cara lainnya adalah melakukan mapping buffer object ke dalam RAM dan anda dapat memodifikasi data dengan pointer ke mapped buffer. Berikut penjelasannya.

glMapBufferARB()
glMapBufferARB() untuk melakukan mapping buffer object ke dalam RAM.

void* glMapBufferARB(GLenum target, GLenum access)

contoh:
float *ptr
= (float*)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_READ_WRITE_ARB);

Parameter target sama seperti penjelasan sebelumnya. Sedang access menentukan tujuan menggunakan mapped data:

read : GL_READ_ONLY_ARB
write : GL_WRITE_ONLY_ARB
read and write :GL_READ_WRITE_ARB

glMapBufferARB() menyebabkan masalah sinkronisasi. Jika GPU sedang bekerja pada buffer object maka glMapBufferARB() tidak akan berfungsi hingga GPU selesai menyelesaikan tugasnya yang berkaitan dengan buffer object. Untuk mencegah idle time, anda dapat memanggil glBufferDataARB() dengan NULL pointer, dan kemudian memanggil glMapBufferARB(). Dalam hal ini, data sebelumnya akan dibatalkan dan kemudian glMapBufferARB() akan segera memberikan alokasi pointer baru, meskipun GPU masih bekerja dengan data sebelumnya.

Bagaimanapun, metode ini berlaku jika anda ingin mengubah data set yang ada karena anda membatalkan data sebelumnya. Tetapi jika anda ingin mengubah sebagian data atau hanya ingin membaca data, maka sebaiknya anda tidak membatalkan data sebelumnya.

glUnmapBufferARB()
Setelah memodifikasi data pada VBO, anda harus melakukan unmapping buffer object dari RAM.

GLboolean glUnmapBufferARB(GLenum target)

glUnmapBufferARB() memberikan nilai GL_TRUE jika berhasil. Jika ia mengembalikan GL_FALSE, ini berarti data pada VBO mengalami corrupt ketika proses mapping buffer object ke RAM. Untuk kasus ini, data baru harus dikirim ulang ke VBO. Berikut sample code untuk modifikasi data pada VBO.

// bind then map the VBO
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboId);
float* ptr
= (float*)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);


// if the pointer is valid(mapped), update VBO
if(ptr)
{
updateMyVBO(ptr, ...);                 // modify buffer data
glUnmapBufferARB(GL_ARRAY_BUFFER_ARB); // unmap it after use
}


// you can draw the updated VBO
...

referensi: song ho ahn

download sample code(VStudio2005) : SampleVBO.rar, diperlukan library glut dan glew

That night was a very eventful night indeed. Amar and I probably became two of the few fortunate amateur astronomers in India who would've gotten to use a 40" telescope, and even look through it.

The night of 12th June 2007 was pretty eventful for us. We had Mr. K. Kuppuswamy on duty, to operate the Zeiss 1m telescope and the PixCellent 1K CCD camera attached to it. The skies were clearing, but there was lightning at a distance in the north. We were walking on the corridor along with Mr. Kuppuswamy, learning about the joint discovery of Uranus' rings, about how it was an observation of Uranus' occultation of a star from 4 observatories (including the Kuiper Airborne Observatory, which is credited for this discovery) and how Dr. J C Bhattacharya was looking through the eyepiece and Mr. Kuppuswamy at the photomultiplier's graph-sheet recorder noticed a sudden drop of the number of counts, waiting for the lightning to subside.

Finally, we went in and switched on the console, after the lightning became less. But the humidity was rising. We quickly took spectra of each of Jupiter's moons, 6 spectra of Jupiter (in different slit positions) and the spectrum of Vesta. In between somewhere, Mr. Kuppuswamy was taking the comparison spectrum and we noticed dew formation on the CCD. He pumped in nitrogen. The dew went away. We had continued our photography. Soon, the Nitrogen would no longer help, not even a continuous supply. We shut down the CCD and did some visual observing at the eyepiece of the spectrograph, just for fun!

It was a nice experience for all three of us. We requested Mr. Kuppuswamy to slew to M22. I went to the UAGS' eyepiece and saw an "Open cluster"!!! Such was the resolving power of the 40"! We slewed to M27 sometime, but it required extreme averted vision - the night wasn't very clear, and the f/13 scope's magnification was such that M27 filled the whole eyepiece field of view!! We also slewed to "Blinking Planetary" in Cygnus. We could see the blue colour easily and I don't remember whether or not we saw the central star. It was a good sight, though.

Jupiter through the 8" f/15 finder scope was probably the best view of Jupiter I've had till date. The amazing refractor from Zeiss is only a finder scope for the 40"!! To center an object, you first take note of its RA/Dec, slew the telescope till IIA's Dome Control program reads the same, then center it in the 8" (I don't remember if the 4" was functional. If it was, we'd have had to center it there first), then in the eyepiece of the UAGS of the mighty 40"!

I still appreciate the beautiful complexity of IRAF. I managed to install it finally and it now works. I processed today, 1 year later, the images taken about 364.8 days ago! (Please bow down to my postponing skills). And seeing the results today bring to me almost the same joy that the experience of taking them did.

IMPORTANT NOTE: I have not confirmed whether I have copyrights for these images. Although these images have been uploaded, they belong to Dr. B S Shylaja of the JNP. I will be verifying with her the copyrights of these images shortly.

These spectra were taken with the Universal Astronomical Grating Spectrograph (UAGS) and PixCellent 1K CCD camera with 2x2 binning at the Zeiss 1m telescope at the Vainu Bappu Observatory, Kavalur. Thanks to Dr. Sunetra Giridhar, Dr. B S Shylaja and the Director, IIA for giving me an opportunity to avail these spectra.

I didn't have the Fe-Ne comparison chart, so I had to virtually cook-up values for spectral lines looking at this, and comparing the spectrum of Vega that we took on 9th June 2007 with this. Interestingly, the spectrum of Vega matches pretty well and it puts what I think is the H-Beta line at 4879 angstrom instead of 4861 angstrom, which is an error of 0.4%!

Spectrum of some portion of Jupiter. (The details of which portion this is are in my log book that I left with Dr. Shylaja.)

This is after removing a vague continuum spectrum from Jupiter's spectrum above. We can again see the H-Beta line @ ~486nm and the feature at the Sodium and Helium D lines. This doesn't mean the Jupiter is full of Hydrogen, but is because the light from Jupiter is reflected sunlight! I need to learn and subtract the Solar Spectrum from this to get a pure Jupiter's reflectance spectrum.

This is the spectrum of Vega. It matches pretty well with the one I linked in earlier. The feature at 600nm is what I used to align the comparison spectrum!

This is the spectrum of Vega, after removing the continuum. The continuum matched very well in this case (pure blackbody!) and once that was removed, the features became more clear. Once can see the same features of Hydrogen and Helium (?) at 486 nm and 587 nm. Wikipedia lists a diatomic oxygen Fraunhofer line at 628nm, and I was wondering if the small peak at a similar location could be that. I have not subtracted the sky spectrum. I'm yet to check out the possibility of doing this.

I really enjoyed the processing. It took me all night. I didn't have my notes on IRAF commands, so it was partly from memory that you had to do something called 'epar apall' and from Google. These documents helped me:
1. The Zen of IRAF for the CCD Processing part
2. The IRAF FAQ on exporting for the final image export
3. User's Guide to reducing Slit Spectra with IRAF for teaching me how to set reference spectra the hard way (for some reason, epar refspec wouldn't work and would trim out the imh from the reference spectrum image name. I don't know, it didn't seem to work for me.)
There were a lot more that I can't remember / didn't bother to copy URLs of / that were random "Googlings".

It was fun reviving something that I learnt an year ago and finally getting satisfactory results!

Livy.nl: zelf de manier van aan- en verkoop van je woning bepalen

Zelf doen op internet is hot. Tachtig procent van alle Nederlanders start de koop of verkoop van de eigen woning online. Toch blijft het meestal bij oriënteren op sites als Funda, Jaap of Marktplaats. Want de meeste mensen komen nog altijd bij een traditionele- of internetmakelaar terecht. Vanaf 1 februari kan het anders. Dan is het mogelijk om via Livy.nl zelf de manier van kopen en verkopen te bepalen. Met of zonder makelaar. Of: alleen de makelaar voor bepaalde diensten.
Alles zelf doen en geld besparen. Zo veel mogelijk zelf doen en de makelaar alleen voor sommige zaken inschakelen. Kiezen voor zekerheid en alles aan de makelaar overlaten. Met Livy.nl bepaal je het zelf.

Geavanceerde tools
Livy.nl maakt geavanceerde makelaarstools voor iedereen beschikbaar. Daarmee is het mogelijk om zelf een woningpresentatie samen te stellen. Compleet met foto's, video's, woninggegevens, persoonlijke tekst en uitleg. Ook krijgt Livy-gebruiker waardevolle tips en adviezen uit de makelaarswereld.

Persoonlijk dossier
Wanneer de woningpresentatie wordt gepubliceerd op internet, kan de woningverkoop beginnen: afspraken maken, bezichtigingen regelen, onderhandelen over de prijs en de overdracht organiseren. Alles wordt online bijgehouden in een persoonlijk dossier. Een woning kopen via Livy.nl verloopt via een vergelijkbaar stappenplan. Van het vinden van een woning tot en met de feitelijke overdracht.

Lokale NVM-makelaar
Hulp en ondersteuning van een lokale NVM-makelaar kan via Livy.nl direct worden geregeld. Bijvoorbeeld voor het vaststellen van de vraagprijs, hulp bij bezichtigingen, onderhandelingen en de afhandeling van de koopovereenkomst. Elke dienst heeft een vast tarief. Zo kan de Livy-gebruiker zelf bepalen waarvoor de makelaar wordt ingeschakeld.

Testfase in Almere afgerond
Vanaf oktober 2007 is Livy.nl uitgebreid getest in de regio Almere. Op basis van de feedback van gebruikers is het internetplatform continu aangepast en doorontwikkeld. Het resultaat hiervan wordt op 1 februari gelanceerd op www.livy.nl.

Initiatief van NVM-makelaars
Livy.nl is een initiatief van een groep Nederlandse NVM-makelaars. De dienstverlening richting de consument wordt gegarandeerd door een landelijk netwerk van aangesloten NVM-kantoren.

ALMERE - Consumenten die hun woning willen verkopen kunnen voortaan zelf makelaar spelen op de nieuwe website www.livy.nl. Als ze er niet uitkomen bij het taxeren van de woning, het regelen van bezichtigingen of het maken van foto's kunnen ze bij elke stap een NVM-makelaar inhuren. Door per geleverde dienst te betalen bepaalt de consument zelf het tarief van de makelaar.

Het is de eerste keer in Nederland dat makelaars de consument wegwijs maken in hun eigen werkwijze en geen totaaltarief, maar een tarief per geleverde dienst berekenen. Normaal gesproken betaalt de consument een percentage van de verkoopprijs of een vast tarief voor de makelaar.

De Stichting Livy in Almere is een initiatief van een groep NVM-makelaars. Dit jaar zullen 320 erkende makelaars zich aansluiten. Zij beseffen dat ze door de opkomst van woningverkopen via Internet veel klanten aan het verliezen zijn. Via Livy.nl bieden ze de consument de mogelijkheid via zelfwerkzaamheid geld te besparen, maar ook om op een simpele manier een makelaar in te schakelen.

Op de website biedt Livy.nl de consument eenvoudige zogeheten makelaarstools aan. Bijvoorbeeld om zelf een woningpresentatie te maken, compleet met foto's, video's, woninggegevens, persoonlijke tekst en uitleg. Ook krijgt de Livy-gebruiker tips en adviezen uit de makelaarswereld.

Via de website kan de consument in een persoonlijk dossier alle gegevens over de verkoop bijhouden, afspraken maken, bezichtigingen regelen, onderhandelen over de prijs en de overdracht organiseren. Een woning kopen via Livy.nl verloopt via een vergelijkbaar stappenplan. Van het vinden van een woning tot en met de feitelijke overdracht.

,,Andere websites verzamelen vaak een zo groot mogelijk aanbod aan woningen, maar je kunt er niet zomaar je huis op verkopen. Op onze website is alles transparant gemaakt. Je wordt door het hele proces begeleid. Je kunt zoveel mogelijk zelf doen en geld besparen of kiezen voor zekerheid en sommige zaken of alles aan de makelaar overlaten", legt Marc Kuipers van Livy het concept uit.

Uit een prijsvergelijking met andere websites waarop consumenten hun huis kunnen verkopen blijkt dat Livy.nl in alle gevallen goedkoper uitvalt voor de consument. Zelfs wanneer de consument kiest voor alle makelaarsdiensten.

Voor meer informatie: www.livy.nl

http://users.design.ucla.edu/%7Eacolubri/shaders/painter.html

This means that if you go to eBay and just search, "VBO" - you will find an array of listings that are on sale and discounted like crazy!

VBO! VBO!