// Using rules, CPT and binding to predict cases, return prediction results.
Pred predict(const vector<Constraint>& cons, const vector<CPTRow>& cpt, const vector<string>& plst, const vector<string>& nlst)
{
Pred resu;
resu.TP = -1;
resu.FP = -1;
resu.TN = -1;
resu.FN = -1;
int TP = 0;
for(size_t i = 0; i < plst.size(); i++)
{
string gene = plst[i];
int idx = classification(gene, cons);
if(cpt[idx].k0 <= cpt[idx].k1)
TP++;
}
resu.TP = TP;
resu.FN = (int)plst.size() - TP;
int TN = 0;
for(size_t i = 0; i < nlst.size(); i++)
{
string gene = nlst[i];
int idx = classification(gene, cons);
if(cpt[idx].k0 > cpt[idx].k1)
TN++;
}
resu.TN = TN;
resu.FP = (int)nlst.size() - TN;
return resu;
}
int naiveBayes(Data_t *dataset, int lweight, int ldistance, int rweight, int rdistance, Results_t *results, int datacount)
{
int ret = SUCCEED;
Data_t values = { FAIL, lweight, ldistance, rweight, rdistance};
results->left = classification(dataset, CLASSNAME, LEFT, values, datacount);
results->balance = classification(dataset, CLASSNAME, BALANCE, values, datacount);
results->right = classification(dataset, CLASSNAME, RIGHT, values, datacount);
return ret;
}
CStdString PDFDocumentTagger::GetClassification()
{
CDIntfEx::IDIDocumentPtr spDocument;
HRESULT hr = spDocument.CreateInstance(__uuidof(CDIntfEx::Document));
if(S_OK != hr)
throw Workshare::Com::ComException(_T("Unable to create instance of PDF Document"), hr);
VARIANT_BOOL bOpen = spDocument->Open(m_fileName.c_str());
if(VARIANT_FALSE == bOpen)
{
CStdString sError;
sError.Format(_T("Failed to open PDF document %s"), m_fileName.c_str());
throw Workshare::System::SystemException(sError);
}
CStdString classificationTag(c_sNoClassification);
try
{
PDFPropertyHandler pph(spDocument->KeyWords);
classificationTag = pph.GetProperty(c_sWSClassification);
}
catch(...)
{
return c_sNoClassification;
}
CStdString classification(classificationTag);
int nEqualsPos = classification.Find('=');
if (nEqualsPos == -1)
return c_sNoClassification;
return classification.Mid(nEqualsPos + 1);
}
// Operator overload for different parameter.
vector<BPred> predict(const vector<Constraint>& cons, const vector<CPTRow>& cpt, const vector<Case>& genlst, int label)
{
vector<BPred> vbpred;
for(size_t i = 0; i < genlst.size(); i++)
{
BPred bpred;
string gene = genlst[i].name;
int idx = classification(gene, cons);
bpred.prob = (double)cpt[idx].k1/(cpt[idx].k0+cpt[idx].k1);
bpred.label = label;
bpred.name = gene;
vbpred.push_back(bpred);
}
return vbpred;
}
/*
Pour attendre l'utilisateur tapper des commandes
Cette methode va traitter des commandes entrées pour
réaliser des besoin en rappant des autres méthodes correspondantes
*/
void Control::processCommand(int argc, char* argv[])
{
std::string command, image_name;
if(argc < 2)
return;
command = std::string(argv[1]);
if(command.compare(CMD_HIST) == 0)
{
image_name = std::string(argv[2]);
this->drawHistogram(image_name);
}
if(command.compare(CMD_CLASS) == 0)
{
std::string csv_train = std::string(argv[2]);
std::string csv_test = std::string(argv[3]);
classification(csv_train, csv_test);
}
}
void Node::parseAll()
{
n();
dn();
d2n();
i();
Omega();
omega();
M();
e();
bstar();
satelliteNumber();
satelliteName();
designator();
classification();
ephemerisType();
elementNumber();
revolutionNumber();
preciseEpoch();
}
// Construct conditional probability table given gene list, constraints and motif binding.
void constrcpt(vector<CPTRow>& cpt, vector<CPTRow>& ppt, const vector<Case>& genlst, const vector<Constraint>& cons)
{
if(cons.size() < 1)
{
cpt.clear();
return;
}
// Set prior CPT.
setprior(ppt, cons);
// Initialize the CPT.
initcpt(cpt, (size_t)pow((double)2, (int)cons.size()));
// Classify each gene and increase the corresponding CPT entry by one.
for(size_t i = 0; i < genlst.size(); i++)
{
int tidx = classification(genlst[i].name, cons);
if(genlst[i].label == 0)
cpt[tidx].k0++;
else if(genlst[i].label == 1)
cpt[tidx].k1++;
}
}
std::string Node::secondString() const
{
std::string res = "1 ";
res += string2string(satelliteNumber(), 5);
const char cl = classification();
res += (isprint(cl) ? std::string(1, cl) : " ") + " ";
res += string2string(designator(), 8) + " ";
res += date2string(preciseEpoch(), 14) + " ";
res += double2string(dn(), 10, 8, false, false, false) + " ";
res += double2string(d2n(), 8, 3, true, true, false) + " ";
res += double2string(bstar(), 8, 3, true, true, false) + " ";
const char eph = ephemerisType();
res += (isprint(eph) ? std::string(1, eph) : " ") + " ";
res += int2string(elementNumber(), 4, false);
// Checksum
int sum = checksum(res);
res += int2string(sum, 1);
return res;
}
Wt::WString User::classification_str() const {
return classification2str(classification());
}
int main(int argc, char *argv[])
{
/* Variables' declarations */
int nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row, subregion = 0, nsubregions = 0;
double N_extension, E_extension, edgeE, edgeN;
int dim_vect, nparameters, BW, npoints;
double lambda_B, lambda_F, grad_H, grad_L, alpha, mean;
const char *dvr, *db, *mapset;
char table_interpolation[GNAME_MAX], table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int last_row, last_column, flag_auxiliar = FALSE;
int *lineVect;
double *TN, *Q, *parVect_bilin, *parVect_bicub; /* Interpolating and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
/* Structs' declarations */
struct Map_info In, Out;
struct Option *in_opt, *out_opt, *stepE_opt, *stepN_opt,
*lambdaF_opt, *lambdaB_opt, *gradH_opt, *gradL_opt, *alfa_opt;
struct Flag *spline_step_flag;
struct GModule *module;
struct Cell_head elaboration_reg, original_reg;
struct Reg_dimens dims;
struct bound_box general_box, overlap_box;
struct Point *observ;
dbDriver *driver;
/*------------------------------------------------------------------------------------------*/
/* Options' declaration */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("LIDAR"));
G_add_keyword(_("edges"));
module->description =
_("Detects the object's edges from a LIDAR data set.");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
stepE_opt = G_define_option();
stepE_opt->key = "see";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "4";
stepE_opt->description =
_("Interpolation spline step value in east direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "sen";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "4";
stepN_opt->description =
_("Interpolation spline step value in north direction");
stepN_opt->guisection = _("Settings");
lambdaB_opt = G_define_option();
lambdaB_opt->key = "lambda_g";
lambdaB_opt->type = TYPE_DOUBLE;
lambdaB_opt->required = NO;
lambdaB_opt->description =
_("Regularization weight in gradient evaluation");
lambdaB_opt->answer = "0.01";
lambdaB_opt->guisection = _("Settings");
gradH_opt = G_define_option();
gradH_opt->key = "tgh";
gradH_opt->type = TYPE_DOUBLE;
gradH_opt->required = NO;
gradH_opt->description =
_("High gradient threshold for edge classification");
gradH_opt->answer = "6";
gradH_opt->guisection = _("Settings");
gradL_opt = G_define_option();
gradL_opt->key = "tgl";
gradL_opt->type = TYPE_DOUBLE;
gradL_opt->required = NO;
gradL_opt->description =
_("Low gradient threshold for edge classification");
gradL_opt->answer = "3";
gradL_opt->guisection = _("Settings");
alfa_opt = G_define_option();
alfa_opt->key = "theta_g";
alfa_opt->type = TYPE_DOUBLE;
alfa_opt->required = NO;
alfa_opt->description = _("Angle range for same direction detection");
alfa_opt->answer = "0.26";
alfa_opt->guisection = _("Settings");
lambdaF_opt = G_define_option();
lambdaF_opt->key = "lambda_r";
lambdaF_opt->type = TYPE_DOUBLE;
lambdaF_opt->required = NO;
lambdaF_opt->description =
_("Regularization weight in residual evaluation");
lambdaF_opt->answer = "2";
lambdaF_opt->guisection = _("Settings");
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
line_out_counter = 1;
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda_F = atof(lambdaF_opt->answer);
lambda_B = atof(lambdaB_opt->answer);
grad_H = atof(gradH_opt->answer);
grad_L = atof(gradL_opt->answer);
alpha = atof(alfa_opt->answer);
grad_L = grad_L * grad_L;
grad_H = grad_H * grad_H;
if (!(db = G__getenv2("DB_DATABASE", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of database"));
if (!(dvr = G__getenv2("DB_DRIVER", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of driver"));
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
sprintf(table_interpolation, "%s_edge_Interpolation", xname);
}
else {
sprintf(table_name, "%s_aux", out_opt->answer);
sprintf(table_interpolation, "%s_edge_Interpolation", out_opt->answer);
}
/* Something went wrong in a previous v.lidar.edgedetection execution */
if (db_table_exists(dvr, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Something went wrong in a previous v.lidar.edgedetection execution */
if (db_table_exists(dvr, db, table_interpolation)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
if (P_Drop_Aux_Table(driver, table_interpolation) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Checking vector names */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
}
Vect_set_open_level(1);
/* Open input vector */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
/* Input vector must be 3D */
if (!Vect_is_3d(&In))
G_fatal_error(_("Input vector map <%s> is not 3D!"), in_opt->answer);
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
G_message("Estimated point density: %.4g", dens);
G_message("Estimated mean distance between points: %.4g", dist);
}
else
G_warning(_("No points in current region!"));
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/* Open output vector */
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z))
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
/* Create auxiliar and interpolation table */
if ((flag_auxiliar = P_Create_Aux4_Table(driver, table_name)) == FALSE)
G_fatal_error(_("It was impossible to create <%s>."), table_name);
if (P_Create_Aux2_Table(driver, table_interpolation) == FALSE)
G_fatal_error(_("It was impossible to create <%s> interpolation table in database."),
out_opt->answer);
db_create_index2(driver, table_name, "ID");
db_create_index2(driver, table_interpolation, "ID");
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(dvr, db);
/* Setting regions and boxes */
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims);
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(P_BICUBIC, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(_("adjusted EW splines %d"), nsplx_adj);
G_verbose_message(_("adjusted NS splines %d"), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north - elaboration_reg.south) / stepN) +
0.5;
/*
if (nsply > NSPLY_MAX) {
nsply = NSPLY_MAX;
}
*/
G_debug(1, "nsply = %d", nsply);
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each column */
subregion++;
if (nsubregions > 1)
G_message(_("subregion %d of %d"), subregion, nsubregions);
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east - elaboration_reg.west) / stepE) +
0.5;
/*
if (nsplx > NSPLX_MAX) {
nsplx = NSPLX_MAX;
}
*/
G_debug(1, "nsplx = %d", nsplx);
/*Setting the active region */
dim_vect = nsplx * nsply;
G_debug(1, "read vector region map");
observ =
P_Read_Vector_Region_Map(&In, &elaboration_reg, &npoints,
dim_vect, 1);
if (npoints > 0) { /* If there is any point falling into elaboration_reg... */
int i, tn;
nparameters = nsplx * nsply;
/* Mean's calculation */
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
/* Least Squares system */
G_debug(1, _("Allocating memory for bilinear interpolation"));
BW = P_get_BandWidth(P_BILINEAR, nsply); /* Bilinear interpolation */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect_bilin = G_alloc_vector(nparameters); /* Bilinear parameters vector */
obsVect = G_alloc_matrix(npoints + 1, 3); /* Observation vector */
Q = G_alloc_vector(npoints + 1); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints + 1);
/* Setting obsVect vector & Q matrix */
for (i = 0; i < npoints; i++) {
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
obsVect[i][2] = observ[i].coordZ - mean;
lineVect[i] = observ[i].lineID;
Q[i] = 1; /* Q=I */
}
G_free(observ);
G_verbose_message(_("Bilinear interpolation"));
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints, nparameters,
BW);
nCorrectGrad(N, lambda_B, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect_bilin, TN, nparameters, BW);
G_free_matrix(N);
for (tn = 0; tn < nparameters; tn++)
TN[tn] = 0;
G_debug(1, _("Allocating memory for bicubic interpolation"));
BW = P_get_BandWidth(P_BICUBIC, nsply);
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
parVect_bicub = G_alloc_vector(nparameters); /* Bicubic parameters vector */
G_verbose_message(_("Bicubic interpolation"));
normalDefBicubic(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints, nparameters,
BW);
nCorrectLapl(N, lambda_F, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect_bicub, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_verbose_message(_("Point classification"));
classification(&Out, elaboration_reg, general_box,
overlap_box, obsVect, parVect_bilin,
parVect_bicub, mean, alpha, grad_H, grad_L,
dims.overlap, lineVect, npoints, driver,
table_interpolation, table_name);
G_free_vector(parVect_bilin);
G_free_vector(parVect_bicub);
G_free_matrix(obsVect);
G_free_ivector(lineVect);
} /* IF */
else {
G_free(observ);
G_warning(_("No data within this subregion. "
"Consider changing the spline step."));
}
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
/* Dropping auxiliar table */
if (npoints > 0) {
G_debug(1, _("Dropping <%s>"), table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_warning(_("Auxiliar table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_map_add_dblink(&Out, F_INTERPOLATION, NULL, table_interpolation,
"id", db, dvr);
Vect_close(&Out);
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*!END MAIN */
std::vector<Dimension> Reader::getDefaultDimensions()
{
std::vector<Dimension> output;
Dimension alpha("Alpha", dimension::UnsignedInteger, 1,
"The alpha image channel value associated with this point");
alpha.setUUID("f3806ee6-e82e-45af-89bd-59b20cda8ffa");
alpha.setNamespace(s_getName());
output.push_back(alpha);
Dimension classification("Classification", dimension::UnsignedInteger, 1,
"Classification code 0-255");
classification.setUUID("845e23ca-fc4b-4dfc-aa71-a40cc2927421");
classification.setNamespace(s_getName());
output.push_back(classification);
Dimension point_source("PointSourceId", dimension::UnsignedInteger, 1,
"Flightline number 0-255");
point_source.setUUID("68c03b56-4248-4cca-ade5-33e90d5c5563");
point_source.setNamespace(s_getName());
output.push_back(point_source);
Dimension point_source2("PointSourceId", dimension::UnsignedInteger, 2,
"Flightline number 0-65536");
point_source2.setUUID("7193bb9f-3ca2-491f-ba18-594321493789");
point_source2.setNamespace(s_getName());
output.push_back(point_source2);
Dimension return_number("ReturnNumber", dimension::UnsignedInteger, 1,
"Echo/Return Number. 0 - Only echo. 1 - First of many echo. 2 - Intermediate echo. 3 - Last of many echo.");
return_number.setUUID("465a9a7e-1e04-47b0-97b6-4f826411bc71");
return_number.setNamespace(s_getName());
output.push_back(return_number);
Dimension return_number2("ReturnNumber", dimension::UnsignedInteger, 2,
"Echo/Return Number. 0 - Only echo. 1 - First of many echo. 2 - Intermediate echo. 3 - Last of many echo.");
return_number2.setUUID("43a1c59d-02ae-4a05-85af-526fae890eb9");
return_number2.setNamespace(s_getName());
output.push_back(return_number2);
Dimension flag("Flag", dimension::UnsignedInteger, 1,
"Runtime flag (view visibility)");
flag.setUUID("583a5904-ee67-47a7-9fba-2f46daf11441");
flag.setNamespace(s_getName());
output.push_back(flag);
Dimension mark("Mark", dimension::UnsignedInteger, 1,
"Runtime flag");
mark.setUUID("e889747c-2f19-4244-b282-b0b223868401");
mark.setNamespace(s_getName());
output.push_back(mark);
Dimension intensity("Intensity", dimension::UnsignedInteger, 2,
"Runtime flag");
intensity.setUUID("beaa015b-20dd-4922-bf1d-da6972596fe6");
intensity.setNamespace(s_getName());
output.push_back(intensity);
Dimension x("X", dimension::SignedInteger, 4,
"X dimension as a scaled integer");
x.setUUID("64e530ee-7304-4d6a-9fe4-231b6c960e69");
x.setNamespace(s_getName());
output.push_back(x);
Dimension y("Y", dimension::SignedInteger, 4,
"Y dimension as a scaled integer");
y.setUUID("9b4fce29-2846-45fa-be0c-f50228407f05");
y.setNamespace(s_getName());
output.push_back(y);
Dimension z("Z", dimension::SignedInteger, 4,
"Z dimension as a scaled integer");
z.setUUID("464cd1f6-5bec-4610-9f25-79e839ee39a6");
z.setNamespace(s_getName());
output.push_back(z);
Dimension red("Red", dimension::UnsignedInteger, 1,
"Red color value 0 - 256 ");
red.setUUID("2157fd43-a492-40e4-a27c-7c37b48bd55c");
red.setNamespace(s_getName());
output.push_back(red);
Dimension green("Green", dimension::UnsignedInteger, 1,
"Green color value 0 - 256 ");
green.setUUID("c9cd71ef-1ce0-48c2-99f8-5b283e598eac");
green.setNamespace(s_getName());
output.push_back(green);
Dimension blue("Blue", dimension::UnsignedInteger, 1,
"Blue color value 0 - 256 ");
blue.setUUID("649f383f-8a7a-4658-ac2a-e1e36cfed05e");
blue.setNamespace(s_getName());
output.push_back(blue);
Dimension time("Time", dimension::UnsignedInteger, 4,
"32 bit integer time stamps. Time stamps are assumed to be "
"GPS week seconds. The storage format is a 32 bit unsigned "
"integer where each integer step is 0.0002 seconds.");
time.setNumericScale(0.0002);
time.setNumericOffset(0.0);
time.setUUID("0dcda772-56da-47f6-b04a-edad72361da9");
time.setNamespace(s_getName());
output.push_back(time);
return output;
}
