Index: trunk/Ohana/src/libautocode/def/SkyRegion.d =================================================================== --- trunk/Ohana/src/libautocode/def/SkyRegion.d (revision 41421) +++ trunk/Ohana/src/libautocode/def/SkyRegion.d (revision 41422) @@ -12,11 +12,11 @@ FIELD parent, PARENT, int, sequence number in full table of parent FIELD index, INDEX, int, sequence number in full table of this entry -FIELD depth, DEPTH, byte, depth of this entry -FIELD child, CHILD, byte, does this entry have children? -FIELD table, TABLE, byte, does this entry have a table? +FIELD depth, DEPTH, gfbyte, depth of this entry +FIELD child, CHILD, gfbyte, does this entry have children? +FIELD table, TABLE, gfbyte, does this entry have a table? FIELD name, NAME, char[18], name / filename -FIELD hostFlags, HOST_FLAGS, byte, flags to define host / backup usage -FIELD hostID, HOST_ID, byte, host ID where data is stored -FIELD backupID, BACKUP_ID, byte, host ID where backup is stored +FIELD hostFlags, HOST_FLAGS, gfbyte, flags to define host / backup usage +FIELD hostID, HOST_ID, gfbyte, host ID where data is stored +FIELD backupID, BACKUP_ID, gfbyte, host ID where backup is stored # note : 2012.02.05 : stole 3 bytes from 'name' to use for host ID and Index: trunk/Ohana/src/libautocode/generate =================================================================== --- trunk/Ohana/src/libautocode/generate (revision 41421) +++ trunk/Ohana/src/libautocode/generate (revision 41422) @@ -118,5 +118,5 @@ $pt1 = 0; if ($type eq "char") { $pt1 = "A"; } - if ($type eq "byte") { $pt1 = "B"; } + if ($type eq "gfbyte") { $pt1 = "B"; } if ($type eq "unsigned char") { $pt1 = "B"; } if ($type eq "rawshort") { $pt1 = "I"; } @@ -225,5 +225,5 @@ $pt1 = 0; if ($type eq "char") { $pt1 = sprintf "A%s", $length; } - if ($type eq "byte") { $pt1 = sprintf "I%s", $length; } + if ($type eq "gfbyte") { $pt1 = sprintf "I%s", $length; } if ($type eq "unsigned char") { $pt1 = sprintf "I%s", $length; } if ($type eq "rawshort") { $pt1 = sprintf "I%s", $length; } @@ -308,5 +308,5 @@ $n = 0; if ($type eq "char") { $N += $Np; next; } - if ($type eq "byte") { $N += $Np; next; } + if ($type eq "gfbyte") { $N += $Np; next; } if ($type eq "unsigned char") { $N += $Np; next; } if ($type eq "rawshort") { $N += 2*$Np; next; } @@ -355,5 +355,5 @@ $valid = 0; if ($type eq "char") { $Nbytes += 1*$Np; $valid = 1; } - if ($type eq "byte") { $Nbytes += 1*$Np; $valid = 1; } + if ($type eq "gfbyte") { $Nbytes += 1*$Np; $valid = 1; } if ($type eq "unsigned char") { $Nbytes += 1*$Np; $valid = 1; } if ($type eq "rawshort") { $Nbytes += 2*$Np; $valid = 1; } Index: trunk/Ohana/src/libdvo/src/skyregion_gsc.c =================================================================== --- trunk/Ohana/src/libdvo/src/skyregion_gsc.c (revision 41421) +++ trunk/Ohana/src/libdvo/src/skyregion_gsc.c (revision 41422) @@ -33,4 +33,5 @@ void SkyTableL3fromL2 (SkyRegion *L2, SkyTable *L3, SkyTable *L4, SkyTable *band, int Ns, int Ne); void SkyTableL4fromL3 (SkyRegion *L3, SkyTable *L4); +void SkyTableL5fromL4 (SkyRegion *L4, SkyTable *L5); void SkyTableSort (SkyTable *table); @@ -170,5 +171,26 @@ SkyTableAppend (skytable, &L2, skytable[0].Nregions - L1.Nregions); SkyTableAppend (skytable, &L3, skytable[0].Nregions - L2.Nregions); + + // XXX TEST : for L4 entries in a certain ra,dec range, generate L5 entries: + + SkyTable L5; + L5.Nregions = 0; + L5.Nalloc = 1000; + ALLOCATE (L5.regions, SkyRegion, L5.Nalloc); + + for (i = 0; i < L4.Nregions; i++) { + // only work on a specific square region: + if (L4.regions[i].Rmin < 9.5) continue; + if (L4.regions[i].Rmin > 10.5) continue; + if (L4.regions[i].Dmin < 40.0) continue; + if (L4.regions[i].Dmin > 42.0) continue; + + SkyTableL5fromL4 (&L4.regions[i], &L5); + } + SkyTableAppend (skytable, &L4, skytable[0].Nregions - L3.Nregions); + + SkyTableAppend (skytable, &L5, skytable[0].Nregions - L4.Nregions); + free (L5.regions); free (L0.regions); @@ -543,4 +565,57 @@ } +// append new regions on to the supplied L5 list (may be empty) +void SkyTableL5fromL4 (SkyRegion *L4, SkyTable *L5) { + + int nx, ny, Nr, Nbox; + double Rmin, Dmin, dR, dD; + char name[80]; + + Nr = L5[0].Nregions; + L5[0].Nregions += NDIV*NDIV; + CHECK_REALLOCATE (L5[0].regions, SkyRegion, L5[0].Nalloc, L5[0].Nregions, 0.5*L5[0].Nalloc); + + L4[0].child = TRUE; + L4[0].childS = Nr; + L4[0].childE = L5[0].Nregions; + + // XXX handle the pole regions just a bit differently... + + /* subdivide L4 into NDIV boxes */ + Rmin = L4[0].Rmin; + Dmin = L4[0].Dmin; + dR = (L4[0].Rmax - L4[0].Rmin) / NDIV; + dD = (L4[0].Dmax - L4[0].Dmin) / NDIV; + + Nbox = 0; + for (ny = 0; ny < NDIV; ny ++) { + for (nx = 0; nx < NDIV; nx ++) { + L5[0].regions[Nr].Rmin = Rmin + (nx + 0)*dR; + L5[0].regions[Nr].Rmax = Rmin + (nx + 1)*dR; + L5[0].regions[Nr].Dmin = Dmin + (ny + 0)*dD; + L5[0].regions[Nr].Dmax = Dmin + (ny + 1)*dD; + + L5[0].regions[Nr].index = Nr; + L5[0].regions[Nr].depth = 5; + L5[0].regions[Nr].table = -1; + L5[0].regions[Nr].parent = L4[0].index; + L5[0].regions[Nr].child = FALSE; + L5[0].regions[Nr].childS = 0; + L5[0].regions[Nr].childE = 0; + L5[0].regions[Nr].hostFlags = 0; + L5[0].regions[Nr].hostID = 0; + L5[0].regions[Nr].backupID = 0; + + myAssert (snprintf (name, 80, "%s.%02d", L4[0].name, Nbox) < 80, "overflow"); + strcpy (L5[0].regions[Nr].name, name); + if (DEBUG >= 4) SkyRegionPrint (&L5[0].regions[Nr]); + + Nr ++; + Nbox ++; + } + } + return; +} + // memory neutral void SkyTableAppend (SkyTable *old, SkyTable *new, int Nprev) { @@ -571,5 +646,5 @@ int i; - fprintf (stderr, "L%d:", region[0].depth); + fprintf (stderr, "L%d:", (int) region[0].depth); for (i = 0; i < region[0].depth; i++) { fprintf (stderr, " "); Index: trunk/Ohana/src/libdvo/src/skyregion_io.c =================================================================== --- trunk/Ohana/src/libdvo/src/skyregion_io.c (revision 41421) +++ trunk/Ohana/src/libdvo/src/skyregion_io.c (revision 41422) @@ -121,4 +121,11 @@ } +// load the skytable from the best location: +// 1) if we already have a defined catdir with skytable.fits, use that +// 2) in some cases, user may supply 'SKYFILE' with explicit path (this is not really used) +// 3) if a file does not exist, create a new skytable from the GSC reference +// the GSC reference file contains a hard-code list of region names +// and boundaries. + SkyTable *SkyTableLoadOptimal (char *catdir, char *skyfile, char *gscfile, int readwrite, int depth, int verbose) { Index: trunk/Ohana/src/libfits/include/gfitsio.h =================================================================== --- trunk/Ohana/src/libfits/include/gfitsio.h (revision 41421) +++ trunk/Ohana/src/libfits/include/gfitsio.h (revision 41422) @@ -18,6 +18,6 @@ # endif /* NEWLINE */ -/* gfits_bintable_format returns 'byte' as the type associated with one-byte logical (non-char) values */ -typedef unsigned char byte; +/* gfits_bintable_format returns 'gfbyte' as the type associated with one-byte logical (non-char) values */ +typedef unsigned char gfbyte; /********** FITS Constants *********/ Index: trunk/Ohana/src/libfits/table/F_compress_T.c =================================================================== --- trunk/Ohana/src/libfits/table/F_compress_T.c (revision 41421) +++ trunk/Ohana/src/libfits/table/F_compress_T.c (revision 41422) @@ -191,5 +191,5 @@ goto got_cmptype; } - if (!strcmp (fields[field].datatype, "byte") || + if (!strcmp (fields[field].datatype, "gfbyte") || !strcmp (fields[field].datatype, "char")) { strcpy (fields[field].zctype, "GZIP_1"); @@ -208,5 +208,5 @@ // OVERRIDE: GZIP_2 invalid for B (use GZIP_1) - if (!strcasecmp (fields[field].zctype, "GZIP_2") && !strcmp (fields[field].datatype, "byte")) { + if (!strcasecmp (fields[field].zctype, "GZIP_2") && !strcmp (fields[field].datatype, "gfbyte")) { strcpy (fields[field].zctype, "GZIP_1"); } Index: trunk/Ohana/src/libfits/table/F_get_column.c =================================================================== --- trunk/Ohana/src/libfits/table/F_get_column.c (revision 41421) +++ trunk/Ohana/src/libfits/table/F_get_column.c (revision 41422) @@ -88,5 +88,5 @@ } } - if (!strcmp (type, "byte")) { + if (!strcmp (type, "gfbyte")) { for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { if (!directCopy) { *(char *)Pout = *(char *)Pin*Bscale + Bzero; } @@ -159,5 +159,5 @@ /* convert data in-situ with correct type, byte swap and Bzero/Bscale */ if (!strcmp (type, "char")) return TRUE; - if (!strcmp (type, "byte")) return TRUE; + if (!strcmp (type, "gfbyte")) return TRUE; /* check existing table dimensions */ Index: trunk/Ohana/src/libfits/table/F_set_column.c =================================================================== --- trunk/Ohana/src/libfits/table/F_set_column.c (revision 41421) +++ trunk/Ohana/src/libfits/table/F_set_column.c (revision 41422) @@ -132,5 +132,5 @@ } - if (!strcmp (type, "byte")) { + if (!strcmp (type, "gfbyte")) { for (i = 0; i < Nval*Nrow; i++, Pin+=Nbytes, Pout+=Nbytes) { *(char *)Pout = (*(char *)Pin - Bzero) / Bscale; @@ -338,5 +338,5 @@ SET_VALUES("char", char, "char", char, SWAP_NONE, 1); - SET_VALUES("byte", byte, "char", char, SWAP_NONE, 1); + SET_VALUES("gfbyte", gfbyte, "char", char, SWAP_NONE, 1); SET_VALUES("short", short, "char", char, SWAP_BYTE, 1); SET_VALUES("int", int, "char", char, SWAP_WORD, 1); @@ -345,14 +345,14 @@ SET_VALUES("double", double, "char", char, SWAP_DBLE, 1); - SET_VALUES("char", char, "byte", byte, SWAP_NONE, 1); - SET_VALUES("byte", byte, "byte", byte, SWAP_NONE, 1); - SET_VALUES("short", short, "byte", byte, SWAP_BYTE, 1); - SET_VALUES("int", int, "byte", byte, SWAP_WORD, 1); - SET_VALUES("int64_t", int64_t, "byte", byte, SWAP_DBLE, 1); - SET_VALUES("float", float, "byte", byte, SWAP_WORD, 1); - SET_VALUES("double", double, "byte", byte, SWAP_DBLE, 1); + SET_VALUES("char", char, "gfbyte", gfbyte, SWAP_NONE, 1); + SET_VALUES("gfbyte", gfbyte, "gfbyte", gfbyte, SWAP_NONE, 1); + SET_VALUES("short", short, "gfbyte", gfbyte, SWAP_BYTE, 1); + SET_VALUES("int", int, "gfbyte", gfbyte, SWAP_WORD, 1); + SET_VALUES("int64_t", int64_t, "gfbyte", gfbyte, SWAP_DBLE, 1); + SET_VALUES("float", float, "gfbyte", gfbyte, SWAP_WORD, 1); + SET_VALUES("double", double, "gfbyte", gfbyte, SWAP_DBLE, 1); SET_VALUES("char", char, "short", short, SWAP_NONE, 2); - SET_VALUES("byte", byte, "short", short, SWAP_NONE, 2); + SET_VALUES("gfbyte", gfbyte, "short", short, SWAP_NONE, 2); SET_VALUES("short", short, "short", short, SWAP_BYTE, 2); SET_VALUES("int", int, "short", short, SWAP_WORD, 2); @@ -362,5 +362,5 @@ SET_VALUES("char", char, "int", int, SWAP_NONE, 4); - SET_VALUES("byte", byte, "int", int, SWAP_NONE, 4); + SET_VALUES("gfbyte", gfbyte, "int", int, SWAP_NONE, 4); SET_VALUES("short", short, "int", int, SWAP_BYTE, 4); SET_VALUES("int", int, "int", int, SWAP_WORD, 4); @@ -370,5 +370,5 @@ SET_VALUES("char", char, "int64_t", int64_t, SWAP_NONE, 8); - SET_VALUES("byte", byte, "int64_t", int64_t, SWAP_NONE, 8); + SET_VALUES("gfbyte", gfbyte, "int64_t", int64_t, SWAP_NONE, 8); SET_VALUES("short", short, "int64_t", int64_t, SWAP_BYTE, 8); SET_VALUES("int", int, "int64_t", int64_t, SWAP_WORD, 8); @@ -378,5 +378,5 @@ SET_VALUES("char", char, "float", float, SWAP_NONE, 4); - SET_VALUES("byte", byte, "float", float, SWAP_NONE, 4); + SET_VALUES("gfbyte", gfbyte, "float", float, SWAP_NONE, 4); SET_VALUES("short", short, "float", float, SWAP_BYTE, 4); SET_VALUES("int", int, "float", float, SWAP_WORD, 4); @@ -386,5 +386,5 @@ SET_VALUES("char", char, "double", double, SWAP_NONE, 8); - SET_VALUES("byte", byte, "double", double, SWAP_NONE, 8); + SET_VALUES("gfbyte", gfbyte, "double", double, SWAP_NONE, 8); SET_VALUES("short", short, "double", double, SWAP_BYTE, 8); SET_VALUES("int", int, "double", double, SWAP_WORD, 8); Index: trunk/Ohana/src/libfits/table/F_table_format.c =================================================================== --- trunk/Ohana/src/libfits/table/F_table_format.c (revision 41421) +++ trunk/Ohana/src/libfits/table/F_table_format.c (revision 41422) @@ -24,8 +24,8 @@ switch (*Fchar) { case 'X': - { *Nbytes = 1; strcpy (type, "byte"); *Nval = 1 + (int) Nv / 8; } + { *Nbytes = 1; strcpy (type, "gfbyte"); *Nval = 1 + (int) Nv / 8; } break; case 'L': - { *Nbytes = 1; strcpy (type, "byte"); *Nval = Nv; } + { *Nbytes = 1; strcpy (type, "gfbyte"); *Nval = Nv; } break; case 'A': @@ -33,5 +33,5 @@ break; case 'B': - { *Nbytes = 1; strcpy (type, "byte"); *Nval = Nv; } + { *Nbytes = 1; strcpy (type, "gfbyte"); *Nval = Nv; } break; case 'I': @@ -108,4 +108,6 @@ Type = 'x'; + if (Fchar == 'D') { *Nbytes = 1; strcpy (type, "double"); Type = 'e'; *Nval = Nv; } + if (Fchar == 'E') { *Nbytes = 1; strcpy (type, "float"); Type = 'e'; *Nval = Nv; } if (Fchar == 'F') { *Nbytes = 1; strcpy (type, "float"); Type = 'f'; *Nval = Nv; } if (Fchar == 'I') { *Nbytes = 1; strcpy (type, "int"); Type = 'd'; *Nval = Nv; } @@ -284,5 +286,5 @@ } } - if (!strcmp (type, "byte")) { + if (!strcmp (type, "gfbyte")) { for (j = 0; j < Ny; j++) { for (n = 0; n < Nval; n++) { @@ -377,5 +379,5 @@ } } - if (!strcmp (type, "byte")) { + if (!strcmp (type, "gfbyte")) { for (j = 0; j < Ny; j++) { for (n = 0; n < Nval; n++) { Index: trunk/Ohana/src/libfits/test/tablecomp.c =================================================================== --- trunk/Ohana/src/libfits/test/tablecomp.c (revision 41421) +++ trunk/Ohana/src/libfits/test/tablecomp.c (revision 41422) @@ -45,5 +45,5 @@ ok (gfits_create_table_header (&header, "BINTABLE", "TESTDATA"), "created the table header"); - ok (gfits_define_bintable_column (&header, "B", "VAL_B", "byte", "none", 1.0, 0.0), "defined byte column"); + ok (gfits_define_bintable_column (&header, "B", "VAL_B", "gfbyte", "none", 1.0, 0.0), "defined byte column"); ok (gfits_define_bintable_column (&header, "I", "VAL_I", "short", "none", 1.0, 0.0), "defined short column"); ok (gfits_define_bintable_column (&header, "J", "VAL_J", "int", "none", 1.0, 0.0), "defined int column"); @@ -114,5 +114,5 @@ off_t Nrow; - char *VAL_B_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_B", type, &Nrow, &Ncol); ok (!strcmp (type, "byte"), "read byte table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); + char *VAL_B_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_B", type, &Nrow, &Ncol); ok (!strcmp (type, "gfbyte"), "read byte table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); short *VAL_I_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_I", type, &Nrow, &Ncol); ok (!strcmp (type, "short"), "read short table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); int *VAL_J_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_J", type, &Nrow, &Ncol); ok (!strcmp (type, "int"), "read int table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); @@ -142,5 +142,5 @@ } - ok (!NVAL_B_bad, "byte values match (input vs output)"); + ok (!NVAL_B_bad, "gfbyte values match (input vs output)"); ok (!NVAL_I_bad, "short values match (input vs output)"); ok (!NVAL_J_bad, "int values match (input vs output)"); @@ -183,10 +183,10 @@ ok (gfits_create_table_header (&header, "BINTABLE", "TESTDATA"), "created the table header"); - ok (gfits_define_bintable_column (&header, "B", "VAL_B", "byte", "none", 1.0, 0.0), "defined byte column"); - ok (gfits_define_bintable_column (&header, "I", "VAL_I", "short", "none", 1.0, 0.0), "defined short column"); - ok (gfits_define_bintable_column (&header, "J", "VAL_J", "int", "none", 1.0, 0.0), "defined int column"); - ok (gfits_define_bintable_column (&header, "K", "VAL_K", "long", "none", 1.0, 0.0), "defined long column"); - ok (gfits_define_bintable_column (&header, "E", "VAL_E", "float", "degree", 1.0, 0.0), "defined float column"); - ok (gfits_define_bintable_column (&header, "D", "VAL_D", "double", "degree", 1.0, 0.0), "defined double column"); + ok (gfits_define_bintable_column (&header, "B", "VAL_B", "gfbyte", "none", 1.0, 0.0), "defined byte column"); + ok (gfits_define_bintable_column (&header, "I", "VAL_I", "short", "none", 1.0, 0.0), "defined short column"); + ok (gfits_define_bintable_column (&header, "J", "VAL_J", "int", "none", 1.0, 0.0), "defined int column"); + ok (gfits_define_bintable_column (&header, "K", "VAL_K", "long", "none", 1.0, 0.0), "defined long column"); + ok (gfits_define_bintable_column (&header, "E", "VAL_E", "float", "degree", 1.0, 0.0), "defined float column"); + ok (gfits_define_bintable_column (&header, "D", "VAL_D", "double", "degree", 1.0, 0.0), "defined double column"); // generate the output array that carries the data @@ -247,5 +247,5 @@ off_t Nrow; - char *VAL_B_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_B", type, &Nrow, &Ncol); ok (!strcmp (type, "byte"), "read byte table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); + char *VAL_B_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_B", type, &Nrow, &Ncol); ok (!strcmp (type, "gfbyte"), "read byte table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); short *VAL_I_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_I", type, &Nrow, &Ncol); ok (!strcmp (type, "short"), "read short table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); int *VAL_J_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_J", type, &Nrow, &Ncol); ok (!strcmp (type, "int"), "read int table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); @@ -271,5 +271,5 @@ } - ok (!NVAL_B_bad, "byte values match (input vs output)"); + ok (!NVAL_B_bad, "gfbyte values match (input vs output)"); ok (!NVAL_I_bad, "short values match (input vs output)"); ok (!NVAL_J_bad, "int values match (input vs output)"); @@ -383,5 +383,5 @@ ok (gfits_create_table_header (&header, "BINTABLE", "TESTDATA"), "created the table header"); - ok (gfits_define_bintable_column (&header, "B", "VAL_B", "byte", "none", 1.0, 0.0), "defined byte column"); + ok (gfits_define_bintable_column (&header, "B", "VAL_B", "gfbyte", "none", 1.0, 0.0), "defined byte column"); ok (gfits_define_bintable_column (&header, "I", "VAL_I", "short", "none", 1.0, 0.0), "defined short column"); ok (gfits_define_bintable_column (&header, "J", "VAL_J", "int", "none", 1.0, 0.0), "defined int column"); @@ -444,5 +444,5 @@ off_t Nrow; - char *VAL_B_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_B", type, &Nrow, &Ncol); ok (!strcmp (type, "byte"), "read byte table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); + char *VAL_B_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_B", type, &Nrow, &Ncol); ok (!strcmp (type, "gfbyte"), "read byte table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); short *VAL_I_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_I", type, &Nrow, &Ncol); ok (!strcmp (type, "short"), "read short table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); int *VAL_J_t = gfits_get_bintable_column_data (outheader, outtable, "VAL_J", type, &Nrow, &Ncol); ok (!strcmp (type, "int"), "read int table column"); ok (Nrow == Nval, "right number of rows"); ok (Ncol == 1, "right number of cols"); @@ -472,5 +472,5 @@ } - ok (!NVAL_B_bad, "byte values match (input vs output)"); + ok (!NVAL_B_bad, "gfbyte values match (input vs output)"); ok (!NVAL_I_bad, "short values match (input vs output)"); ok (!NVAL_J_bad, "int values match (input vs output)"); Index: trunk/Ohana/src/opihi/lib.shell/VectorIO.c =================================================================== --- trunk/Ohana/src/opihi/lib.shell/VectorIO.c (revision 41421) +++ trunk/Ohana/src/opihi/lib.shell/VectorIO.c (revision 41422) @@ -511,5 +511,5 @@ // assign the data to the actual vector - ASSIGN_DATA(byte, byte, Int); + ASSIGN_DATA(gfbyte, gfbyte, Int); ASSIGN_DATA(char, char, Int); ASSIGN_DATA(short, short, Int); @@ -537,5 +537,5 @@ // assign the data to the actual vector - ASSIGN_DATA_TRANSPOSE(byte, byte, Int); + ASSIGN_DATA_TRANSPOSE(gfbyte, gfbyte, Int); ASSIGN_DATA_TRANSPOSE(char, char, Int); ASSIGN_DATA_TRANSPOSE(short, short, Int);