Esempio n. 1
0
void ModifyAddPart::createVentParam()
{
    int i, j, k;

    p_vent = paraSwitch("Vent", "Select a vent");
    for (i = 0; i < MAX_VENTS; i++)
    {
        // create description and name
        sprintf(buf, "Vent %d", i);

        // case for the vent switching
        paraCase(buf);

        sprintf(buf, "Vent_%d:Name", i);
        currVentFile[i] = 0;
        p_name[i] = addChoiceParam(buf, "Select a vent type substructure");
        p_name[i]->setValue(numVentDirs, ventdirs, currVentFile[i]);

        sprintf(buf, "Vent_%d:Pos", i);
        p_pos[i] = addFloatVectorParam(buf, "Position");
        p_pos[i]->setImmediate(1);
        p_pos[i]->setValue(0.0, 0.0, 0.0);
        pos[i][0] = pos[i][1] = pos[i][2] = 0.0;

        sprintf(buf, "Vent_%d:Euler", i);
        p_euler[i] = addFloatVectorParam(buf, "Euler Angles");
        p_euler[i]->setImmediate(1);
        p_euler[i]->setValue(0.0, 0.0, 0.0);
        euler[i][0] = euler[i][1] = euler[i][2] = 0.0;

        sprintf(buf, "Vent_%d:Rot", i);
        p_rot[i] = addFloatVectorParam(buf, "Rotation Matrix");
        p_rot[i]->setImmediate(1);

        for (j = 0; j < 3; j++)
        {
            for (k = 0; k < 3; k++)
            {
                if (j == k)
                    coverRot[i][3 * k + j] = 1.0;
                else
                    coverRot[i][3 * k + j] = 0;
            }
        }

        p_rot[i]->setValue(9, coverRot[i]);
        axis[i][0] = 1;
        axis[i][1] = 0;
        axis[i][2] = 0;
        /// vent case ends here
        paraEndCase();
    }
    paraEndSwitch();
}
Esempio n. 2
0
ComputeTrace::ComputeTrace(int argc, char *argv[])
    : coSimpleModule(argc, argv, "Creates traces from points timestep dependent")
    , m_firsttime(true)
{
    //the timesteps shall NOT be handled automatically by the coSimpleModule class
    setComputeTimesteps(1);

    /*Fed in points*/
    p_pointsIn = addInputPort("GridIn0", "Points|Spheres", "a set of points or spheres containing the particle/s to be traced over time");
    p_dataIn = addInputPort("DataIn0", "Float|Byte|Int|Vec2|Vec3|RGBA|Mat3|Tensor", "data mapped associated with spheres");
    p_dataIn->setRequired(false);
    p_IDIn = addInputPort("IDIn0", "Int", "ID of each atom");
    p_IDIn->setRequired(false);
    /*Boolean that specifies if a particle should be traced or not*/
    p_traceParticle = addBooleanParam("traceParticle", "set if particle should be traced");
    p_traceParticle->setValue(1);
    /*Integer that specifies the particle to be traced in Module Parameter window*/
    p_particle = addStringParam("selection", "ranges of selected set elements");
    p_particle->setValue("1-1");
    p_maxParticleNumber = addInt32Param("maxParticleNum", "maximum number of particles to trace");
    p_maxParticleNumber->setValue(100);
    /*Integer that specifies the starting point*/
    p_start = addIntSliderParam("start", "Timestep at which the tracing should be started");
    p_start->setValue(0, 0, 0);
    /*Integer that specifies the ending point*/
    p_stop = addIntSliderParam("stop", "Timestep at which the tracing should be stopped");
    p_stop->setValue(0, 0, 0);
    /* Boolean that specifies if the bounding box leaving should be regarded */
    p_regardInterrupt = addBooleanParam("LeavingBoundingBox", "set if leaving bounding box should be taken into account");
    p_regardInterrupt->setValue(0);
    p_animate = addBooleanParam("animate", "disable for static trace");
    p_animate->setValue(1);
    /* 3 values specifying the x, y and z dimension of the bounding box */
    p_boundingBoxDimensions = addFloatVectorParam("BoundingBoxDimensions", "x, y, z dimensions of the bounding box");
    p_boundingBoxDimensions->setValue(0, 0, 0);
    /*Output should be a line*/
    p_traceOut = addOutputPort("GridOut0", "Lines", "Trace of a specified particle");
    /*unique index per line mappable as color attribute*/
    p_indexOut = addOutputPort("DataOut0", "Float", "unique index for every specified particle");
    /*fade out value per timestep mappable as color attribute*/
    p_fadingOut = addOutputPort("DataOut1", "Float", "fade out value for per vertex coloring of lines over time");
    p_dataOut = addOutputPort("DataOut2", "Float|Byte|Int|Vec2|Vec3|RGBA|Mat3|Tensor", "data mapped to lines");

    p_dataOut->setDependencyPort(p_dataIn);
    IDs = NULL;

    assert(sizeof(animValues) / sizeof(animValues[0]) == AnimNumValues);
    p_animateViewer = addChoiceParam("animateViewer", "Animate Viewer");
    p_animateViewer->setValue(AnimNumValues, animValues, AnimOff);

    p_animLookAt = addFloatVectorParam("animLookAt", "Animated viewer looks at this point");
    p_animLookAt->setValue(0., 0., 0.);
}
Esempio n. 3
0
File: Cube.cpp Progetto: nixz/covise
Cube::Cube(int argc, char *argv[]) // vvvv --- this info appears in the module setup window
    : coModule(argc, argv, "Simple Cube Generation Module")
{
    // output port
    // parameters:
    //   port name
    //   string to indicate connections, convention: name of the data type
    //   description
    p_polyOut = addOutputPort("polygons", "Polygons", "polygons which form the cubes");

    // input parameters
    // parameters:
    //   parameter name
    //   parameter type
    //   description
    p_center = addFloatVectorParam("center", "Center of the cube");
    cx = cy = cz = 0.0;
    p_center->setValue(cx, cy, cz);

    p_cusize = addFloatSliderParam("size", "Size of the cube");
    sMin = 1.0;
    sMax = 100.0;
    sVal = 10.0;
    p_cusize->setValue(sMin, sMax, sVal);
}
Esempio n. 4
0
/*! \brief constructor
 *
 * create In/Output Ports and module parameters here
 */
LoadCadData::LoadCadData(int argc, char **argv)
    : coModule(argc, argv, "Read CAD data")
{

    p_pointName = addOutputPort("model", "Points", "Model");
    p_modelPath = addFileBrowserParam("modelPath", "modelPath");
    p_scale = addFloatParam("scale", "global Scale factor used for OpenCover session");
    p_resize = addFloatVectorParam("resize", "Resize factor");
    p_rotangle = addFloatParam("rotangle", "angle for rotation");
    p_tansvec = addFloatVectorParam("transvec", "Vector for translation");
    p_rotvec = addFloatVectorParam("rotsvec", "Vector for rotation");
    p_backface = addBooleanParam("backface", "Backface Culling");
    p_orientation_iv = addBooleanParam("orientation_iv", "Orientation of iv models like in Inventor Renderer");
    p_convert_xforms_iv = addBooleanParam("convert_xforms_iv", "create LoadCadData DCS nodes");

    p_scale->setValue(-1.0);
    p_rotangle->setValue(0);
    p_resize->setValue(1, 1, 1);
}
Esempio n. 5
0
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ++++
// ++++  Constructor : This will set up module port structure
// ++++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Collect::Collect(int argc, char *argv[])
    : coModule(argc, argv, "Combine grid, normals, colors, textures and vertex "
                           "attributes in one data object for rendering")
{
    // Parameters

    // Ports
    p_grid = addInputPort("GridIn0", "StructuredGrid|UnstructuredGrid|"
                                     "RectilinearGrid|UniformGrid|Points|Spheres"
                                     "|Lines|Polygons|Quads|Triangles|TriangleStrips",
                          "Grid");

    p_color = addInputPort("DataIn0", "Byte|Float|Vec3|RGBA", "Colors or Scalar Data for Volume Visualization");
    p_color->setRequired(0);

    p_norm = addInputPort("DataIn1", "Vec3", "Normals");
    p_norm->setRequired(0);

    p_text = addInputPort("TextureIn0", "Texture", "Textures");
    p_text->setRequired(0);

    p_vertex = addInputPort("VertexAttribIn0", "Vec3|Float", "Vertex Attribute 0");
    p_vertex->setRequired(0);

    p_outPort = addOutputPort("GeometryOut0", "Geometry", "combined object");

#ifdef MATERIAL
    p_material = addMaterialParam("Material", "Material definition for Renderer");
#endif

    p_varName = addStringParam("varName", "name of variant");
    p_varName->setValue("");

    p_attribute = addStringParam("attribute", "attributes in the form name=value;name2=value2;...");
    p_attribute->setValue("");

    p_boundsMinParam = addFloatVectorParam("minBound", "minimum bound");
    p_boundsMinParam->setValue(0., 0., 0.);
    p_boundsMaxParam = addFloatVectorParam("maxBound", "maximum bound");
    p_boundsMaxParam->setValue(0., 0., 0.);
}
Esempio n. 6
0
TestSlider::TestSlider(int argc, char *argv[])
    : coModule(argc, argv, "Simple TestSlider Generation Module")
{
    p_polyOut = addOutputPort("polygons", "Polygons", "polygons which form the cubes");

    p_center = addFloatVectorParam("center", "Center of the cube");
    cx = cy = cz = 0.0;
    p_center->setValue(cx, cy, cz);

    p_cusize = addFloatSliderParam("size", "Size of the cube");
    sMin = 1.0;
    sMax = 10.0;
    sVal = 2.0;
    p_cusize->setValue(sMin, sMax, sVal);
}
Esempio n. 7
0
/// constructor
coColorDistance::coColorDistance(int argc, char *argv[])
    : coSimpleModule(argc, argv, "Compute distance to reference color")
{
    // Create ports:
    piR = addInputPort("Red", "Float", "Scalar volume data (red channel)");
    piR->setInfo("Scalar volume data (red channel)");

    piG = addInputPort("Green", "Float", "Scalar volume data (green channel)");
    piG->setInfo("Scalar volume data (green channel)");

    piB = addInputPort("Blue", "Float", "Scalar volume data (blue channel)");
    piB->setInfo("Scalar volume data (blue channel)");

    poVolume = addOutputPort("Data", "Float", "Scalar volume data");
    poVolume->setInfo("Scalar volume data (range 0-1)");

    // Create parameters:
    paReferenceColor = addColorParam("ReferenceColor", "Color to which the distance is calculated");
    paReferenceColor->setValue(0.0, 0.0, 0.0, 1);

    const char *cs[] = { "RGB", "HSV", "Hue-Saturation", "Hue" };
    paColorSpace = addChoiceParam("ColorSpace", "Color space used for distance calculation");
    paColorSpace->setValue(3, cs, 0);

    const char *metric[] = { "euclidian distance", "manhattan distance", "maximum" };
    paMetric = addChoiceParam("Metric", "Metric for calculation of the distance for transparent values.");
    paMetric->setValue(3, metric, 0);

    paMinMax = addFloatVectorParam("MinMax", "Allowed range of distance.", 2);
    paMinMax->setValue(0, 0.);
    paMinMax->setValue(1, 1.);

    paSlider = addFloatSliderParam("DistanceBase", "This value is added to the calculated distance.");
    paSlider->setValue(-10, 10, 1);

    paSlider2 = addFloatSliderParam("DistanceMultiplier", "This value multiplies the calculated distance.");
    paSlider2->setValue(-10, 10, -1);
}
Esempio n. 8
0
void rechenraum::CreateUserMenu(void)
{
    //   fprintf(stderr, "Entering CreateUserMenu()\n");

    char *tmp;
    int i;
    char path[512];

    p_makeGrid = addBooleanParam("make_grid", "make grid?");
    p_makeGrid->setValue(0);

    p_lockmakeGrid = addBooleanParam("lock_make_grid_button", "lock make grid button?");
    p_lockmakeGrid->setValue(0);

    p_createGeoRbFile = addBooleanParam("create_geo_or_rb_file", "create geo/rb file?");
    p_createGeoRbFile->setValue(0);

    p_gridSpacing = addFloatParam("spacing", "elements per floor square");
    p_gridSpacing->setValue(4.);

    p_model_size = addFloatVectorParam("model_size", "model size");
    p_model_size->setValue(36.54, 22.54, 3.20);

    p_nobjects = addInt32Param("n_objects", "make grid?");
    p_nobjects->setValue(MAX_CUBES);

    p_Q_total = addFloatParam("Q_inlet_m3_h", "total flow rate in m3/h");
    p_Q_total->setValue(320000.);

    p_v_SX9 = addFloatParam("v_SX9", "flow velocity at SX9 inlet and outlet in m/s");
    p_v_SX9->setValue(0.84);

    sprintf(path, "%s/racks.txt", coCoviseConfig::getEntry("value", "Module.Rechenraum.GeorbPath", "/data/rechenraum").c_str());
    p_BCFile = addStringParam("BCFile", "BCFile");
    p_BCFile->setValue(path);

    sprintf(path, "%s/geofile.geo", coCoviseConfig::getEntry("value", "Module.Rechenraum.GeorbPath", "/data/rechenraum").c_str());
    p_geofile = addStringParam("GeofilePath", "geofile path");
    p_geofile->setValue(path);

    sprintf(path, "%s/rbfile.geo", coCoviseConfig::getEntry("value", "Module.Rechenraum.GeorbPath", "/data/rechenraum").c_str());
    p_rbfile = addStringParam("RbfilePath", "rbfile path");
    p_rbfile->setValue(path);

    m_Geometry = paraSwitch("Geometry", "Select Rack");
    geo_labels = (char **)calloc(MAX_CUBES, sizeof(char *));

    for (i = 0; i < MAX_CUBES; i++)
    {
        // create description and name
        geo_labels[i] = IndexedParameterName(GEO_SEC, i);
        paraCase(geo_labels[i]); // Geometry section

        tmp = IndexedParameterName("pos_rack", i);
        p_cubes_pos[i] = addFloatVectorParam(tmp, tmp);
        p_cubes_pos[i]->setValue(0.0, 0.0, 0.0);

        tmp = IndexedParameterName("size_rack", i);
        p_cubes_size[i] = addFloatVectorParam(tmp, tmp);
        p_cubes_size[i]->setValue(0.0, 0.0, 0.0);
        free(tmp);

        paraEndCase(); // Geometry section
    }
    paraEndSwitch(); // "GeCross section", "Select GeCross section"

    m_FlowRate = paraSwitch("FlowRate", "Select Rack");
    flow_labels = (char **)calloc(MAX_CUBES - 1, sizeof(char *)); // racks without escalator and cold house

    float flowrate_racks[MAX_CUBES - 4] = {
        5., //  0 Infrastruktur
        5., //  1 Phoenix
        4., //  2 NAS
        3., //  3 DDN
        3., //  4 Strider
        5., //  5 Blech
        5., //  6 Sx8R
        5., //  7 IBM_BW_Grid
        5., //  8 Disk_Rack_1 (5 Stueck)
        5., //  9 Disk_Rack_2 (5 Stueck)
        5., // 10 Disk_Rack_3 (5 Stueck)
        5., // 11 Disk_Rack_4 (5 Stueck)
        5., // 12 Disk_Rack_5 (4 Stueck)
        5., // 13 Netz1
        5., // 14 Disk_Rack_6 (5 Stueck)
        5., // 15 IOX
        5., // 16 Netz2
        5., // 17 FC_Netz
        5., // 18 Asama
        5., // 19 Disk_Rack_7 (4 Stueck)
        5., // 20 SX9
        5., // 21 Neu1
        5. // 22 Neu2
    };

    for (i = 0; i < MAX_CUBES - 4; i++)
    {
        // create description and name
        flow_labels[i] = IndexedParameterName(FLOW_SEC, i);
        paraCase(flow_labels[i]);

        tmp = IndexedParameterName("flowrate_rack", i);
        p_flowrate[i] = addFloatParam(tmp, tmp);
        p_flowrate[i]->setValue(flowrate_racks[i]);

        paraEndCase(); // FlowRate section
    }

    paraEndSwitch(); // Flowrate section

#ifndef USE_STARTFILE
    setGeoParamsStandardForRechenRaum();
#endif
}
Esempio n. 9
0
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ++++
// ++++  Constructor : This will set up module port structure
/// ++++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ParamTest::ParamTest(int argc, char *argv[])
    : coSimpleModule(argc, argv, "Param Program: Show all parameter types")
{
    //autoInitParam(0);

    // Immediate-mode String parameter
    stringImm = addStringParam("stringImm", "Immediate string");
    stringImm->setValue("This is an immediate String Parameter");

    // Immediate-mode Boolean parameter, pre-set to FALSE
    boolImm = addBooleanParam("boolImm", "Immediate coBooleanParam");
    boolImm->setValue(0);

    iScalImm = addInt32Param("iScalImm", "Immediate coIntScalarParam");
    iScalImm->setValue(123);

    fScalImm = addFloatParam("fScalImm", "Immediate coFloatParam");
    fScalImm->setValue(-12.56f);

    // integer sliders: immediate and non-immediate
    iSlidImm = addIntSliderParam("iSlidImm", "Immediate coIntSliderParam");
    iSlidImm->setValue(1, 27, 16);

    // float sliders: immediate and non-immediate
    fSlidImm = addFloatSliderParam("fSlidImm", "Immediate coFloatSliderParam");
    fSlidImm->setValue(-10.0, 30.0, 0.0);

    // float vector: use default size of 3 and set with 3D setValue function
    fVectImm = addFloatVectorParam("fVectImm", "Immediate coFloatVectorParam");
    fVectImm->setValue(1.34f, 1.889f, -99.87f);

    // it makes no sense to put a file selector in the switch, since
    // it is not displayed in the control panel
    browseImm = addFileBrowserParam("myFile", "a file browser");
    browseImm->setValue("/var/tmp/whatever.txt", "*.txt");
    browseImm->show();

    browse = addFileBrowserParam("my2File", "a file browser");
    browse->setValue("/var/tmp/whatever2.txt", "*.txt");
    browse->show();

    // Now this is a choice : we have the choice between 6 values
    const char *choiceVal[] = {
        "left lower inlet", "left upper inlet",
        "left center inlet", "right center inlet",
        "right lower Inlet", "right upper Inlet"
    };
    choImm = addChoiceParam("choImm", "Nun auch noch Choices");
    choImm->setValue(6, choiceVal, 1);

    // add an input port for 'coDoUnstructuredGrid' objects
    inPortReq = addInputPort("inputReq", "StructuredGrid", "Required input port");

    // add another input port for 'coDoUnstructuredGrid' objects
    inPortNoReq = addInputPort("inputNoReq", "UnstructuredGrid", "Not required input port");

    // tell that this port does not have to be connected
    inPortNoReq->setRequired(0);

    // add an output port for this type
    outPort = addOutputPort("outPort", "coDoUnstructuredGrid", "Output Port");

    // and that's all ... no init() or anything else ... that's done in the lib
}
Esempio n. 10
0
void StarCD::createRegionParam()
{
    int i;
    char buf[32];
    p_region = paraSwitch("region", "Select inlet region");
    for (i = 0; i < MAX_REGIONS; i++)
    {
        // create description and name
        sprintf(buf, "Region %d", i);

        // case for the Region switching
        paraCase(buf);
        // the 'usual parameters

        sprintf(buf, "local%d", i);
        p_euler[i] = addFloatVectorParam(buf, "Local Euler angles");
        p_euler[i]->setActive(0);
        p_euler[i]->setValue(0.0, 0.0, 0.0);

        sprintf(buf, "vel%d", i);
        p_v[i] = addFloatVectorParam(buf, "Velocity");
        p_v[i]->setActive(0);
        p_v[i]->setValue(0.0, 0.0, 0.0);

        sprintf(buf, "vmag%d", i);
        p_vmag[i] = addFloatSliderParam(buf, "V-Magnitude");
        p_vmag[i]->setActive(0);
        p_vmag[i]->setValue(0.0, 1.01, 0.0);

        sprintf(buf, "t__%d", i);
        p_t[i] = addFloatSliderParam(buf, "Temperature");
        p_t[i]->setValue(0.0, 40.0, 20.0);
        p_t[i]->setActive(0);

        sprintf(buf, "den%d", i);
        p_den[i] = addFloatSliderParam(buf, "Density");
        p_den[i]->setActive(0);

        sprintf(buf, "p__%d", i);
        p_p[i] = addFloatSliderParam(buf, "Pressure");
        p_p[i]->setActive(0);

        sprintf(buf, "k__%d", i);
        p_k[i] = addFloatSliderParam(buf, "k");
        p_k[i]->setActive(0);

        sprintf(buf, "eps%d", i);
        p_eps[i] = addFloatSliderParam(buf, "Epsilon");
        p_eps[i]->setActive(0);

        sprintf(buf, "tInt%d", i);
        p_tin[i] = addFloatSliderParam(buf, "Turb. Intens");
        p_tin[i]->setActive(0);

        sprintf(buf, "tLen%d", i);
        p_len[i] = addFloatSliderParam(buf, "Turb. Length");
        p_len[i]->setActive(0);

        // multiple scalars
        int j;

        //sprintf(buf,"scal%d",i);
        //p_scalSw[i] = paraSwitch(buf,"Select scalar");
        //p_scalSw[i]->setActive(0);
        for (j = 0; j < MAX_SCALARS; j++)
        {
            sprintf(buf, "Scalar %d", j + 1);
            //paraCase(buf);

            sprintf(buf, "scal%d_%d", i, j + 1);
            p_scal[i][j] = addFloatSliderParam(buf, "Scalar");
            p_scal[i][j]->setActive(0);

            //paraEndCase();
        }
        //paraEndSwitch();

        // multipla user data
        //sprintf(buf,"user%d",i);
        //p_userSw[i] = paraSwitch(buf,"Select UserData");
        //p_userSw[i]->setActive(0);
        for (j = 0; j < MAX_SCALARS; j++)
        {
            sprintf(buf, "User %d", j + 1);
            //paraCase(buf);
            sprintf(buf, "user%d_%d", i, j + 1);
            p_user[i][j] = addFloatSliderParam(buf, "User Field");
            p_user[i][j]->setActive(0);

            //paraEndCase();
        }
        //paraEndSwitch();

        /// region case ends here
        paraEndCase();
    }
    paraEndSwitch();
}
Esempio n. 11
0
Sample::Sample(int argc, char *argv[])
    : coModule(argc, argv, "Sample data on points, unstructured and uniform grids to a uniform grid")
{

    const char *outsideChoice[] = { "MAX_FLT", "user_defined_fill_value" };
    const char *sizeChoice[] = { "user defined", "8", "16", "32", "64", "128", "256", "512", "1024" };
    const char *algorithmChoices[] = {
        "possible holes",
        "no holes and no expansion",
        "no holes and expansion",
        "accurate and slow"
        /*, "number weights" */
    };
    const char *bounding_boxChoices[] = { "automatic per timestep", "automatic global", "manual" };

    const char *pointSamplingChoices[] = { "linear", "logarithmic", "normalized linear", "normalized logarithmic" };

    // fill value for outside
    outsideChoiceParam = addChoiceParam("outside", "fill value for outside - MAXFLT or number");
    outsideChoiceParam->setValue(2, outsideChoice, 0);

    fillValueParam = addFloatParam("fill_value", "Fill Value if not intersecting");
    fillValueParam->setValue(0.0);

    // choose algorithm
    p_algorithm = addChoiceParam("algorithm", "choose algorithm");
    p_algorithm->setValue(4, algorithmChoices, 2);

    // choose mapping for point sampling
    p_pointSampling = addChoiceParam("point_sampling", "choose mapping for point sampling");
    p_pointSampling->setValue(4, pointSamplingChoices, 2);

    // select dimension in i direction
    iSizeChoiceParam = addChoiceParam("isize", "unigrid size in i direction");
    iSizeChoiceParam->setValue(9, sizeChoice, 3);

    iSizeParam = addInt32Param("user_defined_isize", "user defined i_size");
    iSizeParam->setValue(32);

    jSizeChoiceParam = addChoiceParam("jsize", "unigrid size in j direction");
    jSizeChoiceParam->setValue(9, sizeChoice, 3);

    jSizeParam = addInt32Param("user_defined_jsize", "user defined j_size");
    jSizeParam->setValue(32);

    kSizeChoiceParam = addChoiceParam("ksize", "unigrid size in k direction");
    kSizeChoiceParam->setValue(9, sizeChoice, 3);

    kSizeParam = addInt32Param("user_defined_ksize", "user defined k_size");
    kSizeParam->setValue(32);

    p_bounding_box = addChoiceParam("bounding_box", "bounding box calculation");
    p_bounding_box->setValue(3, bounding_boxChoices, 0); // default to manual

    float boundsIni[3] = { -1.0, -1.0, -1.0 };
    p_P1bound_manual = addFloatVectorParam("P1_bounds", "First point");
    p_P1bound_manual->setValue(3, boundsIni);

    float boundsEnd[3] = { 1.0, 1.0, 1.0 };
    p_P2bound_manual = addFloatVectorParam("P2_bounds", "Second point");
    p_P2bound_manual->setValue(3, boundsEnd);

    // eps to cover numerical problems
    epsParam = addFloatParam("eps", "small value to cover numerical problems");
    epsParam->setValue(0.0);

    // add an input port for 'coDoUnstructuredGrid' objects
    Grid_In_Port = addInputPort("GridIn", "UnstructuredGrid|UniformGrid|RectilinearGrid|StructuredGrid|Points", "Grid input");
    Data_In_Port = addInputPort("DataIn", "Float|Vec3", "Data input");
    Data_In_Port->setRequired(0);
    Reference_Grid_In_Port = addInputPort("ReferenceGridIn", "UniformGrid", "Reference Grid");
    Reference_Grid_In_Port->setRequired(0);

    // add an output port for this type
    Grid_Out_Port = addOutputPort("GridOut", "UniformGrid", "Grid Output Port");
    Data_Out_Port = addOutputPort("DataOut", "Float|Vec3", "Data Output Port");
}