The de­fault font for the con­sole on Win­dows is some basic raster font with­out much sup­port for more ex­ot­ic Uni­code code points. Which kind of sucks for com­mand line pro­grams, if they are deal­ing with Uni­code data and for­eign lan­guages. It is pos­si­ble to change the con­sole font to “Lu­ci­da Con­sole”, which sup­ports a lot more code points, or, if it is in­stalled, to “Con­so­las”, which sup­ports even more code points, by click­ing on the icon in the upper left cor­ner of the con­sole and choos­ing to change the prop­er­ties. But we can’t se­ri­ous­ly ex­pect the user of a script to go through the trou­ble of chang­ing the font of the con­sole man­u­al­ly.

Is it pos­si­ble to change the font of the con­sole in­side a Python script run­ning on said con­sole? Usu­al­ly, the most nat­u­ral thing to do would be to look at the mod­ule win32console, but un­for­tu­nate­ly, it doesn’t im­ple­ment the need­ed call to SetCurrentConsoleFontEx. Too bad, but ba­si­cal­ly just a mere in­con­ve­nience, since we can al­ways do stuff like this using the ctypes mod­ule (with the ad­di­tion­al bonus that since Python 2.5, ctypes is part of the Stan­dard Li­brary, so we don’t have to rely on the avail­abil­i­ty of an ex­ter­nal li­brary). The fol­low­ing code shows how it is done:

Once upon a time, or­na­ments, ding­bats, flour­ish­es, sym­bols and other em­bel­lish­ments were put in spe­cial pi fonts, with the sym­bols mapped to or­di­nary let­ters. For ex­am­ple, in Zapfi­no Extra Or­na­ments, you could type a cap­i­tal let­ter X and get a nice flour­ish, which had noth­ing at all to do with the let­ter X.

With the ad­vent of Open Type and Uni­code, some sym­bols where put in the Pri­vate Use Area of Uni­code. For ex­am­ple, Adobe Gara­mond Pro has three flour­ish­es at the code points U+E09D, U+E09E and U+E09F. That’s a lot bet­ters, since it avoids se­man­tic clash­es (don’t con­fuse search en­gines and other bots by typ­ing an “X” if you don’t mean “X”), and it also de­grades more grace­ful­ly if the in­tend­ed font isn’t avail­able (in which a “can’t print this” sym­bol is a bet­ter choice than the rather mis­lead­ing let­ter “X”).

Still, it is far from per­fect, since it turns the Pri­vate Use Area into some kind of font-ven­dor-spe­cif­ic swamp de­void of any in­ter­op­er­abil­i­ty and mean­ing. After all, any in­for­ma­tion about what U+E09D means is lost, since it could be an or­na­ment, a sym­bol (with a rather spe­cif­ic mean­ing), some rare lig­a­ture or some other ty­po­graph­i­cal fea­ture like a sub­script or a small cap­i­tal. So an even bet­ter ap­proach would be to in­ter­pret or­na­ments as some kind of stylis­tic vari­a­tion of a de­fault or­na­ment, like the bul­let point U+2022. A search en­gine or any other kind of bot would see the let­ter U+2022 and would know (more or less) what it is sup­posed to mean, and the dif­fer­ent or­na­ments could be ac­cessed as an Open Type fea­ture.

With a frame­work like Three.js, it is pret­ty easy to dis­play the faces of sim­ple poly­he­drons using WebGL. But a poly­he­dron, con­sid­ered less as a phys­i­cal and more as a topo­log­i­cal ob­ject, con­sists not only of its faces. In­stead often its ver­tices and edges are equaly in­ter­est­ing, and it would be nice to have an easy way to dis­play them, per­haps as­sign­ing them dif­fer­ent col­ors, to dis­tin­guish dif­fer­ent kinds of ver­tices or dif­fer­ent kinds of edges. With­in the pro­gram Stel­la, ver­tices can be dis­played as small balls and edges as thin tubes, and I wrote a func­tion to be used in con­junc­tion with Three.js which makes it a bit eas­i­er to con­struct sim­i­lar graph­i­cal ob­jects, fol­low­ing a sim­i­lar vi­su­al style, with­in WebGL.

In the fol­low­ing ex­am­ples, I’ll as­sume that we have set up all the usual Three.js stuff with ren­der­ers and vir­tu­al cam­eras and mouse con­trols and lights and that we have de­fined a Scene-ob­ject. Fur­ther­more, I’ll as­sume that we im­port­ed my helper file JAN3D.js which con­tains the func­tion JAN3D.stel­la() (among other stuff; I also in­clud­ed JAN3D.Tiny­Track­ball­Con­trols). I’ll show, using four ex­am­ples, how to use this func­tion.

The WebGL-frame­work Three.js I men­tioned in the pre­vi­ous entry has a nice vari­a­tion of its ren­der­er which ren­ders scenes as red-cyan anaglyphs. So using Three.js, you ba­si­cal­ly get anaglyphs for free with­out any ad­di­tion­al work on your part (an anaglyph is an image where you need glass­es with red and cyan glass­es to get a stereo­scop­ic, three-di­men­sion­al view).

I tried to con­struct a lit­tle scene using this abil­i­ty, but what I dis­liked was that the scene, as an anaglyph, was too dis­tant and ap­peared to be po­si­tioned be­hind the screen. I had a scene with sev­er­al con­cen­tric cir­cles of spheres, and I want­ed them to ap­pear to in­ter­sect the plane of the screen, with the cen­ter of the cir­cles co­in­cid­ing with the screen. And since I found no way of doing it, I plugged two new pa­ram­e­ters into Anaglyph­We­bGLRen­der­er, called the new ver­sion Pro­truding­Anaglyph­Web­GLRen­der­er and put it in a file Pro­truding­Anaglyph­Web­GLRen­der­er.js.