vpSetClassifierTable(3)

💖 vpSetClassifierTable — the manual page, but make it cute 💖

okay bestie, so this is vpSetClassifierTable(3), a VolPack library function, and it's literally the girl who tells VolPack how see-through stuff should be. her whole job? specify an opacity transfer function. that's it. that's the vibe. ✨

---

✨ NAME ✨

vpSetClassifierTable — specify an opacity transfer function 🎀

---

✨ SYNOPSIS ✨

#include <volpack.h>

vpResult
vpSetClassifierTable(vpc, param_num, param_field, table, table_size)
    vpContext *vpc;
    int param_num, param_field;
    float *table;
    int table_size;

---

✨ ARGUMENTS ✨

• vpc — the VolPack context you got from vpCreateContext. your girl. your main character. 🫶
• param_num — parameter number, and it's the one that IDs exactly which parameter of the opacity transfer function we're talking about.
• param_field — field number, identifying which voxel field holds that parameter.
• table — the lookup table that defines the mapping from the voxel field value → the opacity. the glow-up pipeline, basically. 💅
• table_size — size of table, in bytes. yes, bytes. don't come at me. 🌸

---

✨ DESCRIPTION ✨

so vpSetClassifierTable is the one you call to specify lookup tables that define an opacity transfer function. and the opacity transfer function has to be in this exact form:

opacity = f0(param0) * f1(param1) * ... * fN(paramN)

where each factor is a function of one voxel field. (keep reading, because if you want more general classification models, there's a whole workaround below, iykyk.)

you call vpSetClassifierTable once for each factor, to specify the lookup table that defines that factor. then, once the function has been specified, opacities get computed by calling one of the classification functions: vpClassifyScalars, vpClassifyVolume, or vpClassifyScanline. 🦋

and here's how the classifying actually works, no cap: to classify a voxel, those functions use the values in the fields of the voxel as indexes into the opacity transfer function tables, retrieve one value from each table, and multiply the values together to compute the opacity for that voxel. the opacity should be a number in the range 0.0-1.0, so normally each table contains numbers that are also in this range. 👑

the parameters of the opacity transfer function are numbered from zero, and the total number of parameters must be specified using vpSetVoxelSize before calling vpSetClassifierTable. important. periodt.

the number of parameters is independent of the number of voxel fields: some fields may not be used as parameters at all, and one field could be used multiple times (although that's inefficient, since all of the tables indexed by the same parameter could be merged into one table — just saying 🫣).

each table should be a 1D array of numbers with one entry for each possible value of the corresponding voxel field. and the voxel field must contain an unsigned integer quantity. normally you'd declare each table like this:

float table[MAX_FIELD_VALUE + 1];

where MAX_FIELD_VALUE is the maximum possible value in the voxel field, as specified with vpSetVoxelField. the table may also be dynamically allocated, if you're feeling fancy.

⚠️ bestie, listen: VolPack will never free the table, even if the VolPack context is destroyed with vpDestroyContext. so the application is responsible for freeing that memory when appropriate. it's giving "you broke it, you bought it." 💀

the values in the table may be initialized or modified at any time before or after calling vpSetClassifierTable — but before calling one of the classification routines. and ooh, check it: see the function vpRamp for a convenient way to initialize tables with piece-wise linear ramps. 🌈

now, classification functions that are not expressible in the form above? handled like this:

1. first, write your own routine that computes the opacity for each voxel.
2. next, quantize the opacities using somewhere between 8 and 16 bits per voxel, and store the quantized values in one field of each voxel.
3. finally, define an opacity transfer function table that maps the quantized opacities into a floating point number in the range 0.0-1.0, and use that table to define a single-parameter opacity transfer function by calling vpSetClassifierTable.

and one more thing 🎀 — the minimum opacity threshold should be set at the same time as the opacity transfer function. see the VP_MIN_VOXEL_OPACITY argument to vpSetd. don't forget her, she gets lonely.

---

✨ STATE VARIABLES ✨

the current classification function parameters can be retrieved with the following state variable codes (see vpGeti(3)):

• VP_CLASSIFY_FIELD_COUNT
• VP_CLASSIFY_FIELDS
• VP_CLASSIFY_TABLES
• VP_CLASSIFY_TABLE_SIZES
• VP_MIN_VOXEL_OPACITY

---

✨ ERRORS ✨

the normal return value is VP_OK. 💖

the following error return value is possible:

• VPERROR_BAD_VALUE — either param_num or field_num is out of range. (not me being out of range 😭)

---

✨ SEE ALSO ✨

VolPack(3), vpCreateContext(3), vpClassifyScanline(3), vpClassifyScalars(3), vpClassifyVolume(3), vpRamp(3)

---

and that's the whole page, bestie, you ate it. 💅✨ this icon of a manual comes to you straight from VolPack — that's the source and version energy right there, printed on the footer of the original like a little signature, vpSetClassifierTable(3) and all. go classify something gorgeous. 🎀🦋💜