MeshGeometry PrimitiveGeometryBuilder::buildCylinderMesh(std::vector<tgt::vec3>& vertices, size_t numSides, tgt::vec3 color) {
    // Transform vec3 to vec4
    tgt::vec4 color4(color[0], color[1], color[2], 1.f);
    
    // Build cylinder's sides
    MeshGeometry cyl;
    for (size_t i = 0; i < 2*numSides; i+=2) {
        FaceGeometry face;
        
        tgt::vec3 faceNormal = tgt::cross(vertices[i+1] - vertices[i], vertices[i+2] - vertices[i]);
        
        // Face vertices
        // TODO Replace faceNormal with vertex normals for smoother representation
        VertexGeometry fv1(vertices[i], tgt::vec3(0.f), color4, faceNormal);
        VertexGeometry fv2(vertices[i+1], tgt::vec3(0.f), color4, faceNormal);
        VertexGeometry fv3(vertices[i+3], tgt::vec3(0.f), color4, faceNormal);
        VertexGeometry fv4(vertices[i+2], tgt::vec3(0.f), color4, faceNormal);
        face.addVertex(fv1);
        face.addVertex(fv2);
        face.addVertex(fv3);
        face.addVertex(fv4);
        
        cyl.addFace(face);
    }
    return cyl;
}
Beispiel #2
0
MeshListGeometry* ROICube::generateNormalizedMesh(tgt::plane pl) const {
    FaceGeometry planeFace = createQuad(pl, getColor());

    vec4 xm(-1.0f, 0.0f, 0.0f, 1.0f);
    vec4 xp(1.0f, 0.0f, 0.0f, 1.0f);
    vec4 ym(0.0f, -1.0f, 0.0f, 1.0f);
    vec4 yp(0.0f, 1.0f, 0.0f, 1.0f);
    vec4 zm(0.0f, 0.0f, -1.0f, 1.0f);
    vec4 zp(0.0f, 0.0f, 1.0f, 1.0f);

    planeFace.clip(xm);
    planeFace.clip(xp);
    planeFace.clip(ym);
    planeFace.clip(yp);
    planeFace.clip(zm);
    planeFace.clip(zp);

    MeshGeometry mg;

    if(planeFace.getVertexCount() > 2)
        mg.addFace(planeFace);

    MeshListGeometry* mlg = new MeshListGeometry();
    mlg->addMesh(mg);
    return mlg;
}
void MultiVolumeProxyGeometry::process() {
    tgtAssert(inport_.getData()->getVolume(), "no volume");
    tgtAssert(geometry_, "no geometry object");

    geometry_->clear();
    std::vector<VolumeHandle*> data = inport_.getAllData();
    for(size_t d=0; d<data.size(); ++d) {
        if(!data[d])
            continue;

        Volume* volume = data[d]->getVolume();
        tgt::vec3 volumeSize = volume->getCubeSize();

        tgt::vec3 coordLlf = -(volumeSize / static_cast<tgt::vec3::ElemType>(2));
        tgt::vec3 coordUrb =  (volumeSize / static_cast<tgt::vec3::ElemType>(2));

        MeshGeometry mesh = MeshGeometry::createCube(coordLlf, coordUrb, coordLlf, coordUrb);
        //apply dataset transformation matrix:
        mesh.transform(volume->getTransformation());

        //reset tex coords to coords after transformation:
        for(size_t j=0; j<mesh.getFaceCount(); ++j) {
            FaceGeometry& fg = mesh.getFace(j);
            for(size_t k=0; k<fg.getVertexCount(); ++k) {
                VertexGeometry& vg = fg.getVertex(k);
                vg.setTexCoords(vg.getCoords());
            }
        }
        geometry_->addMesh(mesh);
    }

    outport_.setData(geometry_);
}
void MultiVolumeProxyGeometry::process() {
    tgtAssert(inport_.getData()->getRepresentation<VolumeRAM>(), "no volume");

    MeshListGeometry* geometry = new MeshListGeometry();

    std::vector<const VolumeBase*> data = inport_.getAllData();
    for(size_t d=0; d<data.size(); ++d) {
        if(!data[d])
            continue;

        const VolumeBase* volume = data[d];

        tgt::vec3 coordLlf = volume->getLLF();
        tgt::vec3 coordUrb = volume->getURB();


        MeshGeometry mesh = MeshGeometry::createCube(coordLlf, coordUrb, coordLlf, coordUrb);
        //apply dataset transformation matrix:
        mesh.transform(volume->getPhysicalToWorldMatrix());

        //reset tex coords to coords after transformation:
        for(size_t j=0; j<mesh.getFaceCount(); ++j) {
            FaceGeometry& fg = mesh.getFace(j);
            for(size_t k=0; k<fg.getVertexCount(); ++k) {
                VertexGeometry& vg = fg.getVertex(k);
                vg.setTexCoords(vg.getCoords());
            }
        }
        geometry->addMesh(mesh);
    }

    outport_.setData(geometry);
}
Beispiel #5
0
void HypercubeBuilder::rebuildProjections() {
    MeshListGeometry* geom = new MeshListGeometry();

    // Для каждой проекции:
    //for (size_t i = 0; i < numProjections; i++) {
        const MatrixXd points = projection->getPointsMatrix();
        const VectorXd distances = projection->getDistanceVector();
        size_t numPoints = projection->getNumPoints();
        size_t numEdges = projection->getNumEdges();
        size_t numFaces = projection->getNumFaces();
        double maxD = distance_.get();
        // 1) Строим проекции вершин. Отображаем их кубами
        for (size_t j = 0; j < numPoints; j++) {
            double d = distances(j);
            if (d > maxD) continue;
            double a = vertexSize_.get() * 1 / (1 + d) / 10;
            tgt::vec3 cubeSize(a,a,a);
            tgt::vec3 point = pointToVec3(points, j);
            geom->addMesh(MeshGeometry::createCube(point-cubeSize, point+cubeSize));
        }
        
        // 2) Строим проекции ребер. Отображаем их цилиндрами
        if (drawEdges_.get() == true)
        for (size_t j = 0; j < numEdges; j++) {
            Edge e = projection->getEdge(j);
            size_t i1 = e.getV1();
            size_t i2 = e.getV2();
            if (distances(i1) > maxD || distances(i2) > maxD) continue;
            tgt::vec3 v1 = pointToVec3(points, i1);
            tgt::vec3 v2 = pointToVec3(points, i2);
            geom->addMesh(PrimitiveGeometryBuilder::createCylinder(v1, v2, edgeSize_.get() / 10, 4, tgt::vec3(1.,1.,0)));
        }
        
        // 3) Строим проекции граней
        if (drawFaces_.get() == true) {
            MeshGeometry mesh;
            for (size_t j = 0; j < numFaces; j++) {
                Face f = projection->getFace(j);
                
                std::vector<size_t> fv = f.getVertices();
                std::vector<tgt::vec3> projections;
                for (size_t k = 0; k < fv.size(); k++) {
                    projections.push_back(pointToVec3(points, fv[k]));
                }
                
                bool br = false;
                for (size_t k = 0; k < fv.size(); k++) {
                    if (distances(fv[k]) > maxD) br = true;
                }
                if (br == true) continue;
                
                mesh.addFace(PrimitiveGeometryBuilder::createFace(projections, tgt::vec4(1,1,0,0.7)));
            }
            geom->addMesh(mesh);
        }
    //}
    // Delete old geometry and set new
    outport_.setData(geom);
}
Beispiel #6
0
void MeshListGeometry::clip(const tgt::vec4& clipPlane, MeshListGeometry& closingFaces, double epsilon) {
    tgtAssert(epsilon >= 0.0, "negative epsilon");
    for (iterator it = begin(); it != end(); ++it) {
        MeshGeometry closingFace;
        it->clip(clipPlane, closingFace, epsilon);
        if (!closingFace.empty())
            closingFaces.addMesh(closingFace);
    }
}
MeshListGeometry MeshListGeometry::clip(const tgt::vec4& clipplane, double epsilon) {
    MeshListGeometry closingFaces;
    for (iterator it = begin(); it != end(); ++it) {
        MeshGeometry closingFace = it->clip(clipplane, epsilon);
        if (!closingFace.empty())
            closingFaces.addMesh(closingFace);
    }
    return closingFaces;
}
static MeshGeometry*
ConvertObjMesh(istream& in, TextureMapLoader* textureLoader, const std::string& pathName)
{
    ObjLoader loader;
    ObjMaterialLibrary* materialLibrary = NULL;

    MeshGeometry* mesh = loader.loadModel(in);
    if (mesh)
    {
        if (!loader.materialLibrary().empty())
        {
            string materialLibraryFileName = pathName + loader.materialLibrary();
            ifstream matStream(materialLibraryFileName.c_str(), ios::in);
            if (!matStream.good())
            {
                VESTA_LOG("Can't find material library file '%s' for OBJ format mesh", materialLibraryFileName.c_str());
            }
            else
            {
                ObjMaterialLibraryLoader matLoader(textureLoader);
                materialLibrary = matLoader.loadMaterials(matStream);
            }
        }

        if (materialLibrary)
        {
            const vector<string>& materials = loader.materials();
            for (unsigned int i = 0; i < materials.size(); ++i)
            {
                string materialName = materials[i];
                if (!materialName.empty())
                {
                    Material* material = materialLibrary->material(materialName);
                    if (material)
                    {
                        Material* meshMaterial = mesh->material(i);
                        if (meshMaterial)
                        {
                            *meshMaterial = *material;
                        }
                    }
                    else
                    {
                        VESTA_LOG("Missing material in OBJ file: '%s'", materialName.c_str());
                    }
                }
            }

            delete materialLibrary;
        }
    }

    return mesh;
}
Beispiel #9
0
//-----------------------------------------------------------------------------
void _check_coordinates(const MeshGeometry& geometry, const Function& position)
{
  dolfin_assert(position.function_space());
  dolfin_assert(position.function_space()->mesh());
  dolfin_assert(position.function_space()->dofmap());
  dolfin_assert(position.function_space()->element());
  dolfin_assert(position.function_space()->element()->ufc_element());

  if (position.function_space()->element()->ufc_element()->family()
          != std::string("Lagrange"))

  {
    dolfin_error("fem_utils.cpp",
                 "set/get mesh geometry coordinates from/to function",
                 "expecting 'Lagrange' finite element family rather than '%s'",
                 position.function_space()->element()->ufc_element()->family());
  }

  if (position.value_rank() != 1)
  {
    dolfin_error("fem_utils.cpp",
                 "set/get mesh geometry coordinates from/to function",
                 "function has incorrect value rank %d, need 1",
                 position.value_rank());
  }

  if (position.value_dimension(0) != geometry.dim())
  {
    dolfin_error("fem_utils.cpp",
                 "set/get mesh geometry coordinates from/to function",
                 "function value dimension %d and geometry dimension %d "
                 "do not match",
                 position.value_dimension(0), geometry.dim());
  }

  if (position.function_space()->element()->ufc_element()->degree()
          != geometry.degree())
  {
    dolfin_error("fem_utils.cpp",
                 "set/get mesh geometry coordinates from/to function",
                 "function degree %d and geometry degree %d do not match",
                 position.function_space()->element()->ufc_element()->degree(),
                 geometry.degree());
  }
}
Beispiel #10
0
voreen::MeshGeometry MeshGeometry::createCube(tgt::vec3 coordLlf,
        tgt::vec3 coordUrb,
        tgt::vec3 texLlf,
        tgt::vec3 texUrb,
        tgt::vec3 colorLlf,
        tgt::vec3 colorUrb,
        tgt::vec3 normalTop,
        tgt::vec3 normalFront,
        tgt::vec3 normalLeft,
        tgt::vec3 normalBack,
        tgt::vec3 normalRight,
        tgt::vec3 normalBottom,
        float alpha)
{
    FaceGeometry top, front, left, back, right, bottom;
    createCubeFaces(top, front, left, back, right, bottom, coordLlf, coordUrb, texLlf, texUrb, colorLlf, colorUrb, alpha);
    top.setFaceNormal(normalTop);
    front.setFaceNormal(normalFront);
    left.setFaceNormal(normalLeft);
    back.setFaceNormal(normalBack);
    right.setFaceNormal(normalRight);
    bottom.setFaceNormal(normalBottom);

    MeshGeometry mesh;
    mesh.addFace(top);
    mesh.addFace(front);
    mesh.addFace(left);
    mesh.addFace(back);
    mesh.addFace(right);
    mesh.addFace(bottom);

    return mesh;
}
Beispiel #11
0
MeshGeometry MeshGeometry::createCube(vec3 coordLlf,
                                      vec3 coordUrb,
                                      vec3 texLlf,
                                      vec3 texUrb,
                                      vec3 colorLlf,
                                      vec3 colorUrb,
                                      float alpha)
{
    FaceGeometry top, front, left, back, right, bottom;
    createCubeFaces(top, front, left, back, right, bottom, coordLlf, coordUrb, texLlf, texUrb, colorLlf, colorUrb, alpha);

    MeshGeometry mesh;
    mesh.addFace(top);
    mesh.addFace(front);
    mesh.addFace(left);
    mesh.addFace(back);
    mesh.addFace(right);
    mesh.addFace(bottom);

    return mesh;
}
    std::pair<RenderData*, RenderData*> MultiVolumeRaycaster::computeEntryExitPoints(const std::vector<const ImageRepresentationGL*>& images, const CameraData* camera, const RenderData* geometryImage) {
        cgtAssert(_eepShader != nullptr, "EEP Shader must not be 0.");
        const cgt::Camera& cam = camera->getCamera();

        // construct bounding box for all images
        cgt::Bounds b;
        for (size_t i = 0; i < images.size(); ++i) {
            b.addVolume(images[i]->getParent()->getWorldBounds());
        }

        // create proxy geometry
        std::unique_ptr<MeshGeometry> cube(GeometryDataFactory::createCube(b, b));
        // clip proxy geometry against near-plane to support camera in volume
        float nearPlaneDistToOrigin = cgt::dot(cam.getPosition(), -cam.getLook()) - cam.getNearDist() - .002f;
        MeshGeometry clipped = cube->clipAgainstPlane(nearPlaneDistToOrigin, -cam.getLook(), true, 0.02f);

        _eepShader->activate();

        cgt::TextureUnit geometryDepthUnit, entryDepthUnit;
        _eepShader->setUniform("_viewportSizeRCP", 1.f / cgt::vec2(getEffectiveViewportSize()));
        _eepShader->setUniform("_projectionMatrix", cam.getProjectionMatrix());
        _eepShader->setUniform("_viewMatrix", cam.getViewMatrix());

        if (geometryImage != nullptr) {
            geometryImage->bindDepthTexture(_eepShader, geometryDepthUnit, "_geometryDepthTexture", "_geometryDepthTexParams");

            _eepShader->setUniform("_integrateGeometry", true);
            _eepShader->setUniform("_near", cam.getNearDist());
            _eepShader->setUniform("_far", cam.getFarDist());

            cgt::mat4 inverseView = cgt::mat4::identity;
            if (cam.getViewMatrix().invert(inverseView))
                _eepShader->setUniform("_inverseViewMatrix", inverseView);

            cgt::mat4 inverseProjection = cgt::mat4::identity;
            if (cam.getProjectionMatrix().invert(inverseProjection))
                _eepShader->setUniform("_inverseProjectionMatrix", inverseProjection);
        }
        else {
            _eepShader->setUniform("_integrateGeometry", false);
        }

        glEnable(GL_CULL_FACE);
        glEnable(GL_DEPTH_TEST);

        // create entry points texture
        FramebufferActivationGuard f*g(this);
        createAndAttachTexture(GL_RGBA32F);
        createAndAttachDepthTexture();
        _eepShader->setUniform("_isEntrypoint", true);

        glDepthFunc(GL_LESS);
        glClearDepth(1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glCullFace(GL_BACK);
        clipped.render(GL_TRIANGLE_FAN);

        RenderData* entrypoints = new RenderData(_fbo);
        _fbo->detachAll();

        // create exit points texture
        createAndAttachTexture(GL_RGBA32F);
        createAndAttachDepthTexture();
        _eepShader->setUniform("_isEntrypoint", false);

        if (geometryImage != nullptr) {
            entrypoints->bindDepthTexture(_eepShader, entryDepthUnit, "_entryDepthTexture", "_entryDepthTexParams");
        }

        glDepthFunc(GL_GREATER);
        glClearDepth(0.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glCullFace(GL_FRONT);
        clipped.render(GL_TRIANGLE_FAN);

        RenderData* exitpoints = new RenderData(_fbo);
        decorateRenderEpilog(_eepShader);
        _eepShader->deactivate();

        glDepthFunc(GL_LESS);
        glClearDepth(1.0f);
        glCullFace(GL_BACK);
        glDisable(GL_CULL_FACE);
        glDisable(GL_DEPTH_TEST);

        _eepShader->deactivate();
        LGL_ERROR;

        return std::make_pair(entrypoints, exitpoints);
    }
static MeshGeometry*
Convert3DSMesh(Lib3dsFile* meshfile, TextureMapLoader* textureLoader)
{
    MeshGeometry* meshGeometry = new MeshGeometry();

    for (int materialIndex = 0; materialIndex < meshfile->nmaterials; ++materialIndex)
    {
        Lib3dsMaterial* material = meshfile->materials[materialIndex];
        Material* vmaterial = new Material();

        // Convert a 3ds material to VESTA material
        vmaterial->setOpacity(1.0f - material->transparency);
        vmaterial->setDiffuse(Spectrum(material->diffuse));

        if (material->shininess != 0.0f)
        {
            vmaterial->setSpecular(Spectrum(material->specular));
            vmaterial->setPhongExponent(std::pow(2.0f, 1.0f + 10.0f * material->shininess));
        }

        if (material->self_illum_flag)
        {
            vmaterial->setEmission(vmaterial->diffuse() * material->self_illum);
        }

        const string baseTextureName(material->texture1_map.name);
        if (!baseTextureName.empty())
        {
            TextureProperties texProperties;
            if ((material->texture1_map.flags & LIB3DS_TEXTURE_NO_TILE) != 0)
            {
                texProperties.addressS = TextureProperties::Clamp;
                texProperties.addressT = TextureProperties::Clamp;
            }

            if (textureLoader)
            {
                TextureMap* baseTexture = textureLoader->loadTexture(baseTextureName, texProperties);
                vmaterial->setBaseTexture(baseTexture);
            }
        }

        meshGeometry->addMaterial(vmaterial);
    }

    for (int meshIndex = 0; meshIndex < meshfile->nmeshes; ++meshIndex)
    {
        Lib3dsMesh* mesh = meshfile->meshes[meshIndex];
        if (mesh->nfaces > 0)
        {
            bool hasTextureCoords = mesh->texcos != 0;

            // Generate normals for the mesh
            float* normals = new float[mesh->nfaces * 9];
            lib3ds_mesh_calculate_vertex_normals(mesh, (float(*)[3]) normals);

            VertexPool vertexPool;

            for (int faceIndex = 0; faceIndex < mesh->nfaces; ++faceIndex)
            {
                for (int i = 0; i < 3; i++)
                {
                    int vertexIndex = mesh->faces[faceIndex].index[i];
                    vertexPool.addVec3(mesh->vertices[vertexIndex]);
                    vertexPool.addVec3(&normals[(faceIndex * 3 + i) * 3]);

                    if (hasTextureCoords)
                    {
                        // Invert the v texture coordinate, since 3ds uses a texture
                        // coordinate system that is flipped with respect to OpenGL's
                        vertexPool.addVec2(mesh->texcos[vertexIndex][0], 1.0f - mesh->texcos[vertexIndex][1]);
                    }
                }
            }

            delete[] normals;

            const VertexSpec* vertexSpec = hasTextureCoords ? &VertexSpec::PositionNormalTex : &VertexSpec::PositionNormal;
            VertexArray* vertexArray = vertexPool.createVertexArray(mesh->nfaces * 3, *vertexSpec);
            PrimitiveBatch* batch = new PrimitiveBatch(PrimitiveBatch::Triangles, mesh->nfaces);

            // Get the material for the primitive batch
            // TODO: This assumes that a single material is applied to the whole mesh; however,
            // materials can be assigned per-face (but rarely are in most 3ds files.)
            unsigned int materialIndex = Submesh::DefaultMaterialIndex;
            if (mesh->nfaces > 0)
            {
                // Use the material of the first face
                materialIndex = mesh->faces[0].material;
            }

            Submesh* submesh = new Submesh(vertexArray);
            submesh->addPrimitiveBatch(batch, materialIndex);

            meshGeometry->addSubmesh(submesh);
        }
    }

    return meshGeometry;
}
void MultiPlanarProxyGeometry::process() {
    // input volume
    const VolumeBase* inputVolume = inport_.getData();
    tgtAssert(inputVolume, "No input volume");
    tgt::vec3 llf = inputVolume->getLLF();
    tgt::vec3 urb = inputVolume->getURB();
    tgt::vec3 texLlf = tgt::vec3(0.f);
    tgt::vec3 texUrb = tgt::vec3(1.f);

    //
    // x-face
    //
    const float slicePosX = llf.x + slicePosX_.get()*(urb.x - llf.x);
    const float sliceTexX = slicePosX_.get();
    VertexGeometry xLL(tgt::vec3(slicePosX, llf.y, llf.z), tgt::vec3(sliceTexX, texLlf.y, texLlf.z));
    VertexGeometry xLR(tgt::vec3(slicePosX, urb.y, llf.z), tgt::vec3(sliceTexX, texUrb.y, texLlf.z));
    VertexGeometry xUR(tgt::vec3(slicePosX, urb.y, urb.z), tgt::vec3(sliceTexX, texUrb.y, texUrb.z));
    VertexGeometry xUL(tgt::vec3(slicePosX, llf.y, urb.z), tgt::vec3(sliceTexX, texLlf.y, texUrb.z));

    FaceGeometry xFace;
    xFace.addVertex(xLL);
    xFace.addVertex(xLR);
    xFace.addVertex(xUR);
    xFace.addVertex(xUL);

    // We need to double each of the three faces with antiparallel normal vectors,
    // in order to make sure that we have front and back faces. This is necessary,
    // because the MeshEntryExitPoints processor derives the exit points from back faces.

    // these offsets are added to the back faces' slice and tex coords for preventing
    // the ray direction (exitPoint - entryPoint) becoming the null vector.
    const float texCoordOffset = 0.001f;
    const float sliceCoordOffset = 0.00001f;

    const float slicePosXBack = slicePosX-sliceCoordOffset;
    const float sliceTexXBack = sliceTexX-texCoordOffset;
    VertexGeometry xLLBack(tgt::vec3(slicePosXBack, llf.y, llf.z), tgt::vec3(sliceTexXBack, texLlf.y, texLlf.z));
    VertexGeometry xLRBack(tgt::vec3(slicePosXBack, urb.y, llf.z), tgt::vec3(sliceTexXBack, texUrb.y, texLlf.z));
    VertexGeometry xURBack(tgt::vec3(slicePosXBack, urb.y, urb.z), tgt::vec3(sliceTexXBack, texUrb.y, texUrb.z));
    VertexGeometry xULBack(tgt::vec3(slicePosXBack, llf.y, urb.z), tgt::vec3(sliceTexXBack, texLlf.y, texUrb.z));
    FaceGeometry xFaceBack;   //< reverse order of vertices for back face
    xFaceBack.addVertex(xLLBack);
    xFaceBack.addVertex(xULBack);
    xFaceBack.addVertex(xURBack);
    xFaceBack.addVertex(xLRBack);


    //
    // y-face
    //
    const float slicePosY = llf.y + slicePosY_.get()*(urb.y - llf.y);
    const float sliceTexY = slicePosY_.get();
    VertexGeometry yLL(tgt::vec3(llf.x, slicePosY, llf.z), tgt::vec3(texLlf.x, sliceTexY, texLlf.z));
    VertexGeometry yLR(tgt::vec3(urb.x, slicePosY, llf.z), tgt::vec3(texUrb.x, sliceTexY, texLlf.z));
    VertexGeometry yUR(tgt::vec3(urb.x, slicePosY, urb.z), tgt::vec3(texUrb.x, sliceTexY, texUrb.z));
    VertexGeometry yUL(tgt::vec3(llf.x, slicePosY, urb.z), tgt::vec3(texLlf.x, sliceTexY, texUrb.z));
    FaceGeometry yFace;
    yFace.addVertex(yLL);
    yFace.addVertex(yUL);
    yFace.addVertex(yUR);
    yFace.addVertex(yLR);

    // y back face (see above)
    const float slicePosYBack = slicePosY-sliceCoordOffset;
    const float sliceTexYBack = sliceTexY-texCoordOffset;
    VertexGeometry yLLBack(tgt::vec3(llf.x, slicePosYBack, llf.z), tgt::vec3(texLlf.x, sliceTexYBack, texLlf.z));
    VertexGeometry yLRBack(tgt::vec3(urb.x, slicePosYBack, llf.z), tgt::vec3(texUrb.x, sliceTexYBack, texLlf.z));
    VertexGeometry yURBack(tgt::vec3(urb.x, slicePosYBack, urb.z), tgt::vec3(texUrb.x, sliceTexYBack, texUrb.z));
    VertexGeometry yULBack(tgt::vec3(llf.x, slicePosYBack, urb.z), tgt::vec3(texLlf.x, sliceTexYBack, texUrb.z));
    FaceGeometry yFaceBack;
    yFaceBack.addVertex(yLLBack);
    yFaceBack.addVertex(yLRBack);
    yFaceBack.addVertex(yURBack);
    yFaceBack.addVertex(yULBack);


    //
    // z-face
    //
    const float slicePosZ = llf.z + slicePosZ_.get()*(urb.z - llf.z);
    const float sliceTexZ = slicePosZ_.get();
    VertexGeometry zLL(tgt::vec3(llf.x, llf.y, slicePosZ), tgt::vec3(texLlf.x, texLlf.y, sliceTexZ));
    VertexGeometry zLR(tgt::vec3(urb.x, llf.y, slicePosZ), tgt::vec3(texUrb.x, texLlf.y, sliceTexZ));
    VertexGeometry zUR(tgt::vec3(urb.x, urb.y, slicePosZ), tgt::vec3(texUrb.x, texUrb.y, sliceTexZ));
    VertexGeometry zUL(tgt::vec3(llf.x, urb.y, slicePosZ), tgt::vec3(texLlf.x, texUrb.y, sliceTexZ));
    FaceGeometry zFace;
    zFace.addVertex(zLL);
    zFace.addVertex(zLR);
    zFace.addVertex(zUR);
    zFace.addVertex(zUL);

    // z back face (see above)
    const float slicePosZBack = slicePosZ-sliceCoordOffset;
    const float sliceTexZBack = sliceTexZ-texCoordOffset;
    VertexGeometry zLLBack(tgt::vec3(llf.x, llf.y, slicePosZBack), tgt::vec3(texLlf.x, texLlf.y, sliceTexZBack));
    VertexGeometry zLRBack(tgt::vec3(urb.x, llf.y, slicePosZBack), tgt::vec3(texUrb.x, texLlf.y, sliceTexZBack));
    VertexGeometry zURBack(tgt::vec3(urb.x, urb.y, slicePosZBack), tgt::vec3(texUrb.x, texUrb.y, sliceTexZBack));
    VertexGeometry zULBack(tgt::vec3(llf.x, urb.y, slicePosZBack), tgt::vec3(texLlf.x, texUrb.y, sliceTexZBack));
    FaceGeometry zFaceBack;
    zFaceBack.addVertex(zLLBack);
    zFaceBack.addVertex(zULBack);
    zFaceBack.addVertex(zURBack);
    zFaceBack.addVertex(zLRBack);

    // construct output mesh from faces
    MeshGeometry* geometry = new MeshGeometry();
    geometry->addFace(xFace);
    geometry->addFace(xFaceBack);
    geometry->addFace(yFace);
    geometry->addFace(yFaceBack);
    geometry->addFace(zFace);
    geometry->addFace(zFaceBack);

    // assign vertex tex coords as vertex colors so the mesh can be rendered directly (debugging, ...)
    for (size_t faceID=0; faceID<geometry->getFaceCount(); faceID++) {
        for (size_t vertexID=0; vertexID<geometry->getFace(faceID).getVertexCount(); vertexID++) {
            tgt::vec3 texCoords = geometry->getFace(faceID).getVertex(vertexID).getTexCoords();
            geometry->getFace(faceID).getVertex(vertexID).setColor(texCoords);
        }
    }

    outport_.setData(geometry);
}
Beispiel #15
0
MeshGeometry*
CmodLoader::loadMesh()
{
    char headerData[16];
    if (m_inputStream->readRawData(headerData, sizeof(headerData)) != sizeof(headerData))
    {
        setError("Error reading header");
        return NULL;
    }

    QString header = QString::fromLatin1(headerData, sizeof(headerData));
    if (header == "#celmodel__ascii")
    {
        setError("ASCII cmod files are not supported");
        return NULL;
    }
    else if (header != "#celmodel_binary")
    {
        setError("Wrong header; file is not a cmod mesh file");
        return NULL;
    }

    MeshGeometry* mesh = new MeshGeometry();

    // Add the default material
    Material* defaultMaterial = new Material();
    defaultMaterial->setDiffuse(Spectrum::Flat(0.8f));
    defaultMaterial->setBrdf(Material::Lambert);
    mesh->addMaterial(defaultMaterial);

    bool done = false;
    unsigned int meshCount = 0;

    while (!done && !error())
    {
        CmodToken token = readCmodToken();
        if (m_inputStream->atEnd())
        {
            done = true;
        }
        else if (token == CmodMaterial)
        {
            if (meshCount > 0)
            {
                setError("Materials must be appear before any meshes");
            }

            Material* material = loadMaterial();
            if (material)
            {
                mesh->addMaterial(material);
            }
        }
        else if (token == CmodMesh)
        {
            Submesh* submesh = loadSubmesh();
            if (submesh)
            {
                mesh->addSubmesh(submesh);
            }
        }
        else
        {
            setError("Unrecognized block in cmod (not a mesh or material)");
        }
    }

    if (error())
    {
        delete mesh;
        mesh = NULL;
    }

    return mesh;
}
Beispiel #16
0
void VolumeSlicer::setupUniforms(tgt::Shader* slicingPrg) {

    if(!volumeInport_.isReady())
        return;

    tgt::vec3 camPos  = camera_.get().getPosition();
    tgt::vec3 camLook = camera_.get().getLook();

    // Handle Transformation matrix of dataset.
    tgt::mat4 invTransMat = volumeInport_.getData()->getWorldToPhysicalMatrix();
    camPos = (invTransMat * tgt::vec4(camPos, 1.0)).xyz();
    camLook = normalize((invTransMat * tgt::vec4(camLook, 0.0)).xyz());

    tgt::vec3 urb;
    tgt::vec3 llf;

    // disable other than cube-formed proxygeometries for now
    if(!geometryInport_.isReady()) {
        MeshGeometry meshGeometry = volumeInport_.getData()->getBoundingBox(false);
        FaceGeometry f1 = meshGeometry[0];
        FaceGeometry f2 = meshGeometry[1];
        urb = meshGeometry.getTransformationMatrix() * f1[0].getCoords();
        llf = meshGeometry.getTransformationMatrix() * f2[0].getCoords();

    } else {
        //tgt::Bounds b = geometryInport_.getData()->getBoundingBox(true);
        tgt::Bounds b = geometryInport_.getData()->getBoundingBox(false);
        tgt::mat4 m = geometryInport_.getData()->getTransformationMatrix();
        urb = m * b.getURB();
        llf = m * b.getLLF();

        urb = (invTransMat * tgt::vec4(urb, 1.0)).xyz();
        llf = (invTransMat * tgt::vec4(llf, 1.0)).xyz();
    }

    cubeVertices_[0] = tgt::vec3(llf.x, urb.y, urb.z);
    cubeVertices_[1] = tgt::vec3(urb.x, urb.y, urb.z);
    cubeVertices_[2] = tgt::vec3(llf.x, urb.y, llf.z);
    cubeVertices_[3] = tgt::vec3(llf.x, llf.y, urb.z);
    cubeVertices_[4] = tgt::vec3(urb.x, llf.y, urb.z);
    cubeVertices_[5] = tgt::vec3(urb.x, urb.y, llf.z);
    cubeVertices_[6] = tgt::vec3(llf.x, llf.y, llf.z);
    cubeVertices_[7] = tgt::vec3(urb.x, llf.y, llf.z);

    // compute front index needed for clipping
    float minCameraDistance = std::numeric_limits<float>::max(); // distance between camera and closest vertex
    float maxCameraDistance = 0.0;

    for (unsigned int i=0;i<8;i++) {
        float cameraDistance = dot(camLook, cubeVertices_[i] - camPos);
        if (cameraDistance < minCameraDistance) {
            minCameraDistance = cameraDistance;
            frontIdx_ = i;
        }
        if (cameraDistance > maxCameraDistance) {
            maxCameraDistance = cameraDistance;
            backIdx_ = i;
        }
    }

    maxLength_ = dot(camLook, cubeVertices_[backIdx_] - cubeVertices_[frontIdx_]);

    // acquire volume size for sampling
    tgt::ivec3 dim = volumeInport_.getData()->getRepresentation<VolumeGL>()->getTexture()->getDimensions();

    // compute the distance between two adjacent slices in texture coordinates
    sliceDistance_ = maxLength_ / (tgt::max(dim) * samplingRate_.get());

    //if (interactionMode())
    //    sliceDistance /= interactionQuality_.get();

    //clipping uniforms
    slicingPrg->setUniform("frontIdx_", frontIdx_);
    slicingPrg->setUniform("vecView_", camLook);
    slicingPrg->setUniform("dPlaneStart_", dot(camLook, cubeVertices_[frontIdx_]));
    slicingPrg->setUniform("dPlaneIncr_", sliceDistance_);
    slicingPrg->setUniform("nSequence_", nSeq_, 64);
    slicingPrg->setUniform("vecVertices_", cubeVertices_, 8);
    slicingPrg->setUniform("v1_", v1_, 24);
    slicingPrg->setUniform("v2_", v2_, 24);
}
Beispiel #17
0
//------------------------------------------------------------------------------
//!
void
DFPolygonRenderable::update()
{
   Vector<float> egver; // vec3: pos, vec3: color
   Vector<float> vgver; // vec3: pos, vec3: color, flt: size
   Vector<uint32_t> eindices;
   Vector<uint32_t> vindices;

   const DFPolygon* poly = _editor->polygon();

   // Vertices.
   for( auto v = poly->begin(); v != poly->end(); ++v )
   {
      vindices.pushBack( uint(vindices.size()) );
      pushBack( vgver, (*v) );
      pushBack( vgver, _col_v_default );
      pushBack( vgver, _siz_v_default );

      pushBack( egver, (*v) );
      pushBack( egver, _col_e_default );
   }
   // Edges.
   const uint n = uint(poly->numVertices());
   for( uint i = 0, j = n-1; i < n; j=i++ )
   {
      eindices.pushBack( j );
      eindices.pushBack( i );
   }

   // Tweak for selection.
   auto& selection = _editor->selection();
   for( auto cur = selection.begin(); cur != selection.end(); ++cur )
   {
      float* ptr         = vgver.data() + cur->_idx*7;
      Vec3f::as( ptr+3 ) = (*cur) == selection.last() ? _col_v_selected_p : _col_v_selected_s;
      ptr[6]             = _siz_v_selected;
   }

   // Updating the meshes.
   MeshGeometry* emesh = edgeMesh();
   MeshGeometry* vmesh = vertexMesh();

   emesh->clearPatches();
   emesh->deallocate();
   if( !egver.empty() )
   {
      emesh->allocateIndices( uint(eindices.size()) );
      emesh->copyIndices( eindices.data() );
      emesh->allocateVertices( uint(egver.size())/6 );
      emesh->copyAttributes( egver.data(), 6, 6, 0 );
      emesh->addPatch( 0, uint(eindices.size()) );
   }
   emesh->updateProperties();
   emesh->invalidateRenderableGeometry();


   vmesh->clearPatches();
   vmesh->deallocate();
   if( !vgver.empty() )
   {
      vmesh->allocateIndices( uint(vindices.size()) );
      vmesh->copyIndices( vindices.data() );
      vmesh->allocateVertices( uint(vgver.size())/7 );
      vmesh->copyAttributes( vgver.data(), 7, 7, 0 );
      vmesh->addPatch( 0, uint(vindices.size()) );
   }
   vmesh->updateProperties();
   vmesh->invalidateRenderableGeometry();
}
    void SliceRenderer3D::updateResult(DataContainer& data) {
		std::cout << "Entering updateResult of SliceRenderer3D " << std::endl;
		ImageRepresentationGL::ScopedRepresentation img(data, p_sourceImageID.getValue());
        ScopedTypedData<CameraData> camera(data, p_camera.getValue());

        if (img != nullptr && camera != nullptr) {
            if (img->getDimensionality() == 3) {
                const cgt::Camera& cam = camera->getCamera();

                // Creating the slice proxy geometry works as follows:
                // Create the cube proxy geometry for the volume, then clip the cube against the slice plane.
                // The closing face is the slice proxy geometry.
                // This is probably not the fastest, but an elegant solution, which also supports arbitrary slice orientations. :)
                cgt::Bounds volumeExtent = img->getParent()->getWorldBounds();
                std::unique_ptr<MeshGeometry> cube = GeometryDataFactory::createCube(volumeExtent, cgt::Bounds(cgt::vec3(0.f), cgt::vec3(1.f)));

                cgt::vec3 normal(0.f, 0.f, 0.f);
                float p = 0.0f;

				switch (p_sliceOrientation.getOptionValue()) {
				case XY_PLANE:
					normal = cgt::vec3(0.f, 0.f, 1.f);
					p = img->getParent()->getMappingInformation().getOffset().z + (p_sliceNumber.getValue() * img->getParent()->getMappingInformation().getVoxelSize().z);
					break;
				case XZ_PLANE:
					normal = cgt::vec3(0.f, 1.f, 0.f);
					p = img->getParent()->getMappingInformation().getOffset().y + (p_sliceNumber.getValue() * img->getParent()->getMappingInformation().getVoxelSize().y);
					break;
				case YZ_PLANE:
					normal = cgt::vec3(1.f, 0.f, 0.f);
					p = img->getParent()->getMappingInformation().getOffset().x + (p_sliceNumber.getValue() * img->getParent()->getMappingInformation().getVoxelSize().x);
					break;
				}
				MeshGeometry clipped = cube->clipAgainstPlane(p, normal, true);
				const FaceGeometry& slice = clipped.getFaces().back(); // the last face is the closing face

				glEnable(GL_DEPTH_TEST);
                _shader->activate();

                _shader->setIgnoreUniformLocationError(true);
                _shader->setUniform("_viewportSizeRCP", 1.f / cgt::vec2(getEffectiveViewportSize()));
                _shader->setUniform("_projectionMatrix", cam.getProjectionMatrix());
                _shader->setUniform("_viewMatrix", cam.getViewMatrix());

                cgt::TextureUnit inputUnit, tfUnit;
                img->bind(_shader, inputUnit);
                p_transferFunction.getTF()->bind(_shader, tfUnit);

                FramebufferActivationGuard f*g(this);
                createAndAttachColorTexture();
                createAndAttachDepthTexture();
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                slice.render(GL_TRIANGLE_FAN);

                _shader->deactivate();
                cgt::TextureUnit::setZeroUnit();
                glDisable(GL_DEPTH_TEST);

                data.addData(p_targetImageID.getValue(), new RenderData(_fbo));
            }
            else {
                LERROR("Input image must have dimensionality of 3.");
            }
        }
        else {
            LDEBUG("No suitable input image found.");
        }
		std::cout << "Exiting updateResult of SliceRenderer3D " << std::endl;
	}
Beispiel #19
0
//-----------------------------------------------------------------------------
// This helper function sets geometry from position (if setting) or stores
// geometry into position (otherwise)
void _get_set_coordinates(MeshGeometry& geometry, Function& position,
  const bool setting)
{
  auto& x = geometry.x();
  auto& v = *position.vector();
  const auto& dofmap = *position.function_space()->dofmap();
  const auto& mesh = *position.function_space()->mesh();
  const auto tdim = mesh.topology().dim();
  const auto gdim = mesh.geometry().dim();

  std::vector<std::size_t> num_local_entities(tdim+1);
  std::vector<std::size_t> coords_per_entity(tdim+1);
  std::vector<std::vector<std::vector<std::size_t>>> local_to_local(tdim+1);
  std::vector<std::vector<std::size_t>> offsets(tdim+1);

  for (std::size_t dim = 0; dim <= tdim; ++dim)
  {
    // Get number local entities
    num_local_entities[dim] = mesh.type().num_entities(dim);

    // Get local-to-local mapping of dofs
    local_to_local[dim].resize(num_local_entities[dim]);
    for (std::size_t local_ind = 0; local_ind != num_local_entities[dim]; ++local_ind)
      dofmap.tabulate_entity_dofs(local_to_local[dim][local_ind], dim, local_ind);

    // Get entity offsets; could be retrieved directly from geometry
    coords_per_entity[dim] = geometry.num_entity_coordinates(dim);
    for (std::size_t coord_ind = 0; coord_ind != coords_per_entity[dim]; ++coord_ind)
    {
      const auto offset = geometry.get_entity_index(dim, coord_ind, 0);
      offsets[dim].push_back(offset);
    }
  }

  // Initialize needed connectivities
  for (std::size_t dim = 0; dim <= tdim; ++dim)
  {
    if (coords_per_entity[dim] > 0)
      mesh.init(tdim, dim);
  }

  ArrayView<const la_index> cell_dofs;
  std::vector<double> values;
  const unsigned int* global_entities;
  std::size_t xi, vi;

  // Get/set cell-by-cell
  for (CellIterator c(mesh); !c.end(); ++c)
  {
    // Get/prepare values and dofs on cell
    cell_dofs = dofmap.cell_dofs(c->index());
    values.resize(cell_dofs.size());
    if (setting)
      v.get_local(values.data(), cell_dofs.size(), cell_dofs.data());

    // Iterate over all entities on cell
    for (std::size_t dim = 0; dim <= tdim; ++dim)
    {
      // Get local-to-global entity mapping
      global_entities = c->entities(dim);

      for (std::size_t local_entity = 0;
           local_entity != num_local_entities[dim]; ++local_entity)
      {
        for (std::size_t local_dof = 0; local_dof != coords_per_entity[dim];
              ++local_dof)
        {
          for (std::size_t component = 0; component != gdim; ++component)
          {
            // Compute indices
            xi = gdim*(offsets[dim][local_dof] + global_entities[local_entity])
               + component;
            vi = local_to_local[dim][local_entity][gdim*local_dof + component];

            // Set one or other
            if (setting)
              x[xi] = values[vi];
            else
              values[vi] = x[xi];
          }
        }
      }
    }

    // Store cell contribution to dof vector (if getting)
    if (!setting)
      v.set_local(values.data(), cell_dofs.size(), cell_dofs.data());
  }

  if (!setting)
    v.apply("insert");
}
Beispiel #20
0
MeshGeometry MeshGeometry::clip(const vec4& clipplane, double epsilon) {
    // Clip all faces...
    for (iterator it = begin(); it != end(); ++it)
        it->clip(clipplane, epsilon);

    // Remove empty faces...
    for (size_t i = 0; i < faces_.size(); ++i) {
        // Is face empty?
        if (faces_.at(i).getVertexCount() < 3)
            faces_.erase(faces_.begin() + i--);
    }

    // Close convex polyhedron if necessary...
    typedef std::pair<VertexGeometry, VertexGeometry> EdgeType;
    typedef std::vector<EdgeType> EdgeListType;
    typedef std::vector<VertexGeometry> VertexListType;

    EdgeListType edgeList;
    FaceGeometry closingFace;

    // Search all face edges on the clipping plane...
    for (size_t i = 0; i < faces_.size(); ++i) {
        FaceGeometry face = faces_.at(i);

        VertexListType verticesOnClipplane;

        for (size_t j = 0; j < face.getVertexCount(); ++j) {
            if (face.getVertex(j).getDistanceToPlane(clipplane, epsilon) == 0)
                verticesOnClipplane.push_back(face.getVertex(j));

            // Is face in the same plane as the clipping plane?
            if (verticesOnClipplane.size() > 2)
                break;
        }

        // Does one face edge corresponds with clipping plane?
        if (verticesOnClipplane.size() == 2)
            edgeList.push_back(std::make_pair(verticesOnClipplane[0], verticesOnClipplane[1]));
    }

    // Is closing necessary?
    if (edgeList.size() > 1) {
        // Sort edges to produce contiguous vertex order...
        bool reverseLastEdge = false;
        for (size_t i = 0; i < edgeList.size() - 1; ++i) {
            for (size_t j = i + 1; j < edgeList.size(); ++j) {
                VertexGeometry connectionVertex;
                if (reverseLastEdge)
                    connectionVertex = edgeList.at(i).first;
                else
                    connectionVertex = edgeList.at(i).second;

                if (edgeList.at(j).first.equals(connectionVertex, epsilon)) {
                    std::swap(edgeList.at(i + 1), edgeList.at(j));
                    reverseLastEdge = false;
                    break;
                }
                else if (edgeList.at(j).second.equals(connectionVertex, epsilon)) {
                    std::swap(edgeList.at(i + 1), edgeList.at(j));
                    reverseLastEdge = true;
                    break;
                }
            }
        }

        // Convert sorted edge list to sorted vertex list...
        VertexListType closingFaceVertices;
        for (size_t i = 0; i < edgeList.size(); ++i) {
            bool reverseEdge = i != 0 && !closingFaceVertices.at(closingFaceVertices.size() - 1).equals(edgeList.at(i).first);

            VertexGeometry first = (reverseEdge ? edgeList.at(i).second : edgeList.at(i).first);
            VertexGeometry second = (reverseEdge ? edgeList.at(i).first : edgeList.at(i).second);

            if (i == 0)
                closingFaceVertices.push_back(first);
            else
                closingFaceVertices.at(closingFaceVertices.size() - 1).combine(first);

            if (i < (edgeList.size() - 1))
                closingFaceVertices.push_back(second);
            else
                closingFaceVertices[0].combine(second);
        }

        // Convert vertex order to counter clockwise if necessary...
        vec3 closingFaceNormal(0, 0, 0);
        for (size_t i = 0; i < closingFaceVertices.size(); ++i)
            closingFaceNormal += tgt::cross(closingFaceVertices[i].getCoords(), closingFaceVertices[(i + 1) % closingFaceVertices.size()].getCoords());
        closingFaceNormal = tgt::normalize(closingFaceNormal);

        if (tgt::dot(clipplane.xyz(), closingFaceNormal) < 0)
            std::reverse(closingFaceVertices.begin(), closingFaceVertices.end());

        // Close convex polyhedron...
        for (VertexListType::iterator it = closingFaceVertices.begin(); it != closingFaceVertices.end(); ++it) {
            // TODO(b_bolt01): Remove debug message...
            //std::cout << " cfv " << it->getCoords() << std::endl;
            closingFace.addVertex(*it);
        }
        addFace(closingFace);
    }

    // If there is only the clipplane left, erase it also...
    if (faces_.size() == 1)
        faces_.clear();

    MeshGeometry closingMesh;
    if (closingFace.getVertexCount() > 0)
        closingMesh.addFace(closingFace);
    return closingMesh;
}