Beispiel #1
0
void MainWindow::on_remplirDossier_clicked()
{
    saisirinscription uvw(fac);
    if (uvw.exec()){
        fillMainWindow();
    }
}
Beispiel #2
0
void MainWindow::on_inscrireSemestre_clicked()
{
    ajoutSemestres uvw(fac);
    if (uvw.exec()){
        fillMainWindow();
    }
}
Beispiel #3
0
void MainWindow::modifiercursus()
{
    modifiercursuswindow uvw(fac);
    if (uvw.exec()){
        fillMainWindow();
    }
}
Beispiel #4
0
void MainWindow::supprcursus()
{
    supprimerCursus uvw(fac);
    if (uvw.exec()){
        fillMainWindow();
    }
}
Beispiel #5
0
void MainWindow::ajoutercursus()
{
    ajoutcursuswindow uvw(fac);
    if (uvw.exec()){
        fillMainWindow();
    }
}
Beispiel #6
0
void MainWindow::suppruv()
{
    supprimerUVwindow uvw(fac);
    if (uvw.exec()){
        fillMainWindow();
    }
}
Beispiel #7
0
void MainWindow::on_ajouteruv()
{
    ajouterUVwindow uvw(fac);
    if (uvw.exec()){
        fillMainWindow();
    }


}
Beispiel #8
0
bool IndexedTriangleMesh::closestIntersectionModel(const Ray &ray, double maxLambda, RayIntersection& intersection) const
{

  double closestLambda = maxLambda;
  Vec3d closestbary;
  int  closestTri = -1;

  Vec3d bary;
  double lambda;

  // Loop over all stored triangles to find a possible intersection between ray 
  // and any triangle
  for (size_t i=0;i<mIndices.size();i+=3)
  {
    const int i0 = mIndices[i+0];
    const int i1 = mIndices[i+1];
    const int i2 = mIndices[i+2];
    if (Intersection::lineTriangle(ray,mVertexPosition[i0],mVertexPosition[i1],mVertexPosition[i2],bary,lambda) &&
      lambda > 0 && lambda < closestLambda)
    {
      closestLambda = lambda;
      closestbary = bary;
      closestTri = (int)i;
    }
  }

  // If an intersection occurred, compute the normal and the uv coordinates based
  // on the barycentric coordinates of the hit point
  if (closestTri >= 0)
  {
    const int i0 = mIndices[closestTri+0];
    const int i1 = mIndices[closestTri+1];
    const int i2 = mIndices[closestTri+2];

    Vec3d n;
    if(mVertexNormal.empty())
      n = cross(mVertexPosition[i1]-mVertexPosition[i0],mVertexPosition[i2]-mVertexPosition[i0]).normalize();
    else
      n = (mVertexNormal[i0]*closestbary[0]+
           mVertexNormal[i1]*closestbary[1]+
           mVertexNormal[i2]*closestbary[2]).normalize();

    Vec3d uvw(0,0,0);
    if(!mVertexTextureCoordinate.empty())
      uvw = (mVertexTextureCoordinate[i0]*closestbary[0]+
             mVertexTextureCoordinate[i1]*closestbary[1]+
             mVertexTextureCoordinate[i2]*closestbary[2]);
    intersection=RayIntersection(ray,shared_from_this(),closestLambda,n,uvw);
    return true;
  }

  return false;
}
Beispiel #9
0
double M(int m, int n, int l)
{
  double u;
  double v;
  double w;

  uvw(u, v, w, m, n, l);

  return u * U(m, n, l) +
         v * V(m, n, l) +
         w * W(m, n, l);
}
Beispiel #10
0
		/** 
		* Compute barycentric coordinates for a given triangle and a given point
		*/
		point_t barycentric(primitive::triangle_t const& tri, point_t const& point) {
			vector_t v0 = tri.v1 - tri.v0,
					 v1 = tri.v2 - tri.v0,
					 v2 = point - tri.v0;
			float d00 = glm::dot(v0, v0);
			float d01 = glm::dot(v0, v1);
			float d11 = glm::dot(v1, v1);
			float d20 = glm::dot(v2, v0);
			float d21 = glm::dot(v2, v1);
			float d = d00 * d11 - d01 * d01;
			
			point_t uvw(0, 0, 0);
			uvw.y = (d11 * d20 - d01 * d21) / d;
			uvw.z = (d00 * d21 - d01 * d20) / d;
			uvw.x = 1.0f - uvw.y - uvw.z;
			return uvw;
		}
void TweakMouseProc::AverageUVW()
{
	if (mHitLD)
	{
		Point3 uvw(0.0f,0.0f,0.0f);
		int ct = 0;
		for (int i = 0; i < mHitLD->GetNumberTVEdges(); i++ )
		{
			if (!mHitLD->GetTVEdgeHidden(i))
			{
				if (mHitLD->GetTVEdgeVert(i,0) == mHitTVVert)
				{
					uvw += mHitLD->GetTVVert(mHitLD->GetTVEdgeVert(i,1));
					ct++;
				}
				else if (mHitLD->GetTVEdgeVert(i,1) == mHitTVVert)
				{
					uvw += mHitLD->GetTVVert(mHitLD->GetTVEdgeVert(i,0));
					ct++;
				}
			}
		}
		if (ct > 0)
		{
			uvw = uvw/(float)ct;

			mFinalUVW = uvw;
			mHitLD->SetTVVert(GetCOREInterface()->GetTime(),mHitTVVert,mFinalUVW,mod);

			mod->NotifyDependents(FOREVER, PART_TEXMAP, REFMSG_CHANGE);
			mod->InvalidateView();
			if (mod->ip) 
				mod->ip->RedrawViews(mod->ip->GetTime());
		}
	}
}
bool NzOBJParser::Parse()
{
	NzString matName, meshName;
	matName = meshName = "default";
	m_keepLastLine = false;
	m_lineCount = 0;
	m_meshes.clear();
	m_mtlLib.Clear();

	m_normals.clear();
	m_positions.clear();
	m_texCoords.clear();

	// Beaucoup de meshs font plus de 100 sommets, préparons le terrain
	m_normals.reserve(100);
	m_positions.reserve(100);
	m_texCoords.reserve(100);

	// On va regrouper les meshs par nom et par matériau
	std::unordered_map<NzString, std::unordered_map<NzString, std::vector<Face>>> meshes;

	// On prépare le mesh par défaut
	std::vector<Face>* currentMesh = &meshes[meshName][matName];

	while (Advance(false))
	{
		switch (std::tolower(m_currentLine[0]))
		{
			case 'f': // Une face
			{
				if (m_currentLine.GetSize() < 7) // Le minimum syndical pour définir une face de trois sommets (f 1 2 3)
				{
					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
					UnrecognizedLine();
					#endif
					break;
				}

				unsigned int vertexCount = m_currentLine.Count(' ');
				if (vertexCount < 3)
				{
					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
					UnrecognizedLine();
					#endif
					break;
				}

				Face face;
				face.vertices.resize(vertexCount);

				bool error = false;
				unsigned int pos = 2;
				for (unsigned int i = 0; i < vertexCount; ++i)
				{
					int offset;
					int& n = face.vertices[i].normal;
					int& p = face.vertices[i].position;
					int& t = face.vertices[i].texCoord;

					if (std::sscanf(&m_currentLine[pos], "%d/%d/%d%n", &p, &t, &n, &offset) != 3)
					{
						if (std::sscanf(&m_currentLine[pos], "%d//%d%n", &p, &n, &offset) != 2)
						{
							if (std::sscanf(&m_currentLine[pos], "%d/%d%n", &p, &t, &offset) != 2)
							{
								if (std::sscanf(&m_currentLine[pos], "%d%n", &p, &offset) != 1)
								{
									#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
									UnrecognizedLine();
									#endif
									error = true;
									break;
								}
								else
								{
									n = 0;
									t = 0;
								}
							}
							else
								n = 0;
						}
						else
							t = 0;
					}

					if (p < 0)
					{
						p += m_positions.size();
						if (p < 0)
						{
							Error("Vertex index out of range (" + NzString::Number(p) + " < 0");
							error = true;
							break;
						}
					}
					else
						p--;

					if (n < 0)
					{
						n += m_normals.size();
						if (n < 0)
						{
							Error("Vertex index out of range (" + NzString::Number(n) + " < 0");
							error = true;
							break;
						}
					}
					else
						n--;

					if (t < 0)
					{
						t += m_texCoords.size();
						if (t < 0)
						{
							Error("Vertex index out of range (" + NzString::Number(t) + " < 0");
							error = true;
							break;
						}
					}
					else
						t--;

					if (static_cast<unsigned int>(p) >= m_positions.size())
					{
						Error("Vertex index out of range (" + NzString::Number(p) + " >= " + NzString::Number(m_positions.size()) + ')');
						error = true;
						break;
					}
					else if (n >= 0 && static_cast<unsigned int>(n) >= m_normals.size())
					{
						Error("Normal index out of range (" + NzString::Number(n) + " >= " + NzString::Number(m_normals.size()) + ')');
						error = true;
						break;
					}
					else if (t >= 0 && static_cast<unsigned int>(t) >= m_texCoords.size())
					{
						Error("TexCoord index out of range (" + NzString::Number(t) + " >= " + NzString::Number(m_texCoords.size()) + ')');
						error = true;
						break;
					}

					pos += offset;
				}

				if (!error)
					currentMesh->push_back(std::move(face));

				break;
			}

			case 'm':
				#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
				if (m_currentLine.GetWord(0).ToLower() != "mtllib")
					UnrecognizedLine();
				#endif

				m_mtlLib = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
				break;

			case 'g':
			case 'o':
			{
				if (m_currentLine.GetSize() <= 2 || m_currentLine[1] != ' ')
				{
					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
					UnrecognizedLine();
					#endif
					break;
				}

				NzString objectName = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
				if (objectName.IsEmpty())
				{
					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
					UnrecognizedLine();
					#endif
					break;
				}

				meshName = objectName;
				currentMesh = &meshes[meshName][matName];
				break;
			}

			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
			case 's':
				if (m_currentLine.GetSize() <= 2 || m_currentLine[1] == ' ')
				{
					NzString param = m_currentLine.SubString(2);
					if (param != "all" && param != "on" && param != "off" && !param.IsNumber())
						UnrecognizedLine();
				}
				else
					UnrecognizedLine();
				break;
			#endif

			case 'u':
				#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
				if (m_currentLine.GetWord(0) != "usemtl")
					UnrecognizedLine();
				#endif

				matName = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
				if (matName.IsEmpty())
				{
					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
					UnrecognizedLine();
					#endif
					break;
				}

				currentMesh = &meshes[meshName][matName];
				break;

			case 'v':
			{
				NzString word = m_currentLine.GetWord(0).ToLower();
				if (word == 'v')
				{
					NzVector4f vertex(NzVector3f::Zero(), 1.f);
					unsigned int paramCount = std::sscanf(&m_currentLine[2], "%f %f %f %f", &vertex.x, &vertex.y, &vertex.z, &vertex.w);
					if (paramCount >= 3)
						m_positions.push_back(vertex);
					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
					else
						UnrecognizedLine();
					#endif
				}
				else if (word == "vn")
				{
					NzVector3f normal(NzVector3f::Zero());
					unsigned int paramCount = std::sscanf(&m_currentLine[3], "%f %f %f", &normal.x, &normal.y, &normal.z);
					if (paramCount == 3)
						m_normals.push_back(normal);
					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
					else
						UnrecognizedLine();
					#endif
				}
				else if (word == "vt")
				{
					NzVector3f uvw(NzVector3f::Zero());
					unsigned int paramCount = std::sscanf(&m_currentLine[3], "%f %f %f", &uvw.x, &uvw.y, &uvw.z);
					if (paramCount >= 2)
						m_texCoords.push_back(uvw);
					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
					else
						UnrecognizedLine();
					#endif
				}
				#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
				else
					UnrecognizedLine();
				#endif

				break;
			}

			default:
				#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
				UnrecognizedLine();
				#endif
				break;
		}
	}

	std::unordered_map<NzString, unsigned int> materials;
	unsigned int matCount = 0;

	for (auto& meshIt : meshes)
	{
		for (auto& matIt : meshIt.second)
		{
			if (!matIt.second.empty())
			{
				Mesh mesh;
				mesh.faces = std::move(matIt.second);
				mesh.name = meshIt.first;

				auto it = materials.find(matIt.first);
				if (it == materials.end())
				{
					mesh.material = matCount;
					materials[matIt.first] = matCount++;
				}
				else
					mesh.material = it->second;

				m_meshes.push_back(std::move(mesh));
			}
		}
	}

	if (m_meshes.empty())
	{
		NazaraError("No meshes");
		return false;
	}

	m_materials.resize(matCount);
	for (const std::pair<NzString, unsigned int>& pair : materials)
		m_materials[pair.second] = pair.first;

	return true;
}
Beispiel #13
0
void VolSkin::init( int width, int height, TetMesh *tm )
{
	this->width = width;
	this->height = height;

	tetMesh = tm;

	// TEMP initialize volume data
	cudaExtent volumeSize = make_cudaExtent(128, 128, 128);
	//cudaExtent volumeSize = make_cudaExtent(256, 256, 256);

	// generate raw volume data
	float *h_densityData = (float*)malloc( sizeof(float)*volumeSize.width*volumeSize.height*volumeSize.depth );

	math::PerlinNoise pn;
	pn.setDepth( 4 );
	pn.setFrequency(3.0f);
	//pn.setInflection(true);

	for( int k=0;k<volumeSize.depth;++k )
		for( int j=0;j<volumeSize.height;++j )
			for( int i=0;i<volumeSize.width;++i )
			{
				int index = k*volumeSize.width*volumeSize.height + j*volumeSize.width + i;
				math::Vec3f uvw( (float)(i)/(float)(volumeSize.width),
								(float)(j)/(float)(volumeSize.height),
								(float)(k)/(float)(volumeSize.depth));
				float t = (float)(j)/(float)(volumeSize.height);
				//h_densityData[index] = 0.5f;
				//h_densityData[index] = (1.0f-t)*1.0f;
				h_densityData[index] = std::max( 0.0f, pn.perlinNoise_3D( uvw.x, uvw.y*2.0, uvw.z ) )*1.0f; // cylinder
				//h_densityData[index] = std::max( 0.0f, pn.perlinNoise_3D( uvw.x*2.0f, uvw.y*2.0f, uvw.z*2.0f ))*1.0f; // tetraeder
				//h_densityData[index] = (uvw.getLength() < 0.2f ? 1.0f : 0.0f)*2.0f;
			}



    // create 3D array
	d_densityArray = 0;
    cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<float>();
    cudaMalloc3DArray(&d_densityArray, &channelDesc, volumeSize);
	

	// copy data to 3D array
	cudaMemcpy3DParms copyParams = {0};
	copyParams.srcPtr   = make_cudaPitchedPtr((void*)h_densityData, volumeSize.width*sizeof(float), volumeSize.width, volumeSize.height);
	copyParams.dstArray = d_densityArray;
	copyParams.extent   = volumeSize;
	copyParams.kind     = cudaMemcpyHostToDevice;
	cudaMemcpy3D(&copyParams);



	// TMP
	/*
	h_debugVec.resize( 1000.0f );
	d_debugVec = h_debugVec;
	h_debugInfo.samples = convertToKernel(d_debugVec);
	h_debugInfo.numSamples = 0;
	cudaMemcpyToSymbol( d_debugInfo, &h_debugInfo, sizeof(DebugInfo), 0, cudaMemcpyHostToDevice );
	*/

	// setup lighting
	m_light0.cam = base::CameraPtr( new base::Camera() );
	m_light0.cam->m_aspectRatio = 1.0;
	//m_light0.cam->m_transform = math::createLookAtMatrix( math::Vec3f( -2.0f, -2.0f, 2.0f ), math::Vec3f( 0.0f, 0.0f, 0.0f ), math::Vec3f( 0.0f, 1.0f, 0.0f ), false );
	//m_light0.cam->m_transform =  math::Matrix44f::TranslationMatrix( 0.3f, 0.15f, 2.0f );
	//m_light0.cam->m_transform =  math::Matrix44f::TranslationMatrix( -3.0f, 0.0f, 0.0f );
	m_light0.cam->m_transform = math::createLookAtMatrix( math::Vec3f( 4.0f, 0.0f, 0.0f ), math::Vec3f( 0.0f, 0.0f, 0.0f ), math::Vec3f( 0.0f, 1.0f, 0.0f ), false );
	m_light0.cam->update();
	cudaMalloc( &m_light0.d_dctCoefficients, width*height*sizeof(float)*8 );// 8 floats /6 coefficients


		// set defaults
	setTotalCrossSection( 10.0f );
	setAlbedo( 1.0f );
	setAbsorptionColor( math::Vec3f(0.5f,0.5f, 0.5f) );
	setScatteringColor(math::Vec3f(0.5f, 0.5f, 0.5f));
	setLight(0, math::Vec3f(1.0f, 1.0f, 1.0f), 0.0f);
	setTime( 0.0f );
	setStepSize( 0.01f );


	// get tetmesh onto gpu
	gpuUploadTetMesh();

}
Beispiel #14
0
void
RigidArmNode :: computeMasterContribution(std::map< DofIDItem, IntArray > &masterDofID, 
                                          std::map< DofIDItem, FloatArray > &masterContribution)
{
#if 0 // original implementation without support of different LCS in slave and master
    int k;
    IntArray R_uvw(3), uvw(3);
    FloatArray xyz(3);
    int numberOfMasterDofs = masterNode->giveNumberOfDofs();
    //IntArray countOfMasterDofs((int)masterDofID.size());

    // decode of masterMask
    uvw.at(1) = this->dofidmask->findFirstIndexOf(R_u);
    uvw.at(2) = this->dofidmask->findFirstIndexOf(R_v);
    uvw.at(3) = this->dofidmask->findFirstIndexOf(R_w);

    xyz.beDifferenceOf(*this->giveCoordinates(), *masterNode->giveCoordinates());

    if ( hasLocalCS() ) {
        // LCS is stored as global-to-local, so LCS*xyz_glob = xyz_loc
        xyz.rotatedWith(* this->localCoordinateSystem, 'n');
    }

    for ( int i = 1; i <= this->dofidmask->giveSize(); i++ ) {
        Dof *dof = this->giveDofWithID(dofidmask->at(i));
        DofIDItem id = dof->giveDofID();
        masterDofID [ id ].resize(numberOfMasterDofs);
        masterContribution [ id ].resize(numberOfMasterDofs);
        R_uvw.zero();

        switch ( masterMask.at(i) ) {
        case 0: continue;
            break;
        case 1:
            if ( id == D_u ) {
                if ( uvw.at(2) && masterMask.at( uvw.at(2) ) ) {
                    R_uvw.at(3) =  ( ( int ) R_v );
                }

                if ( uvw.at(3) && masterMask.at( uvw.at(3) ) ) {
                    R_uvw.at(2) = -( ( int ) R_w );
                }
            } else if ( id == D_v ) {
                if ( uvw.at(1) && masterMask.at( uvw.at(1) ) ) {
                    R_uvw.at(3) = -( ( int ) R_u );
                }

                if ( uvw.at(3) && masterMask.at( uvw.at(3) ) ) {
                    R_uvw.at(1) =  ( ( int ) R_w );
                }
            } else if ( id == D_w ) {
                if ( uvw.at(1) && masterMask.at( uvw.at(1) ) ) {
                    R_uvw.at(2) =  ( ( int ) R_u );
                }

                if ( uvw.at(2) && masterMask.at( uvw.at(2) ) ) {
                    R_uvw.at(1) = -( ( int ) R_v );
                }
            }

            break;
        default:
            OOFEM_ERROR("unknown value in masterMask");
        }

        //k = ++countOfMasterDofs.at(i);
        k = 1;
        masterDofID [ id ].at(k) = ( int ) id;
        masterContribution [ id ].at(k) = 1.0;

        for ( int j = 1; j <= 3; j++ ) {
            if ( R_uvw.at(j) != 0 ) {
                int sign = R_uvw.at(j) < 0 ? -1 : 1;
                //k = ++countOfMasterDofs.at(i);
                k++;
                masterDofID [ id ].at(k) = sign * R_uvw.at(j);
                masterContribution [ id ].at(k) = sign * xyz.at(j);
            }
        }
        masterDofID [ id ].resizeWithValues(k);
        masterContribution [ id ].resizeWithValues(k);
    }
#else
    // receiver lcs stored in localCoordinateSystem
    // (this defines the transformation from global to local)
    FloatArray xyz(3);
    FloatMatrix TG2L(6,6); // receiver global to receiver local
    FloatMatrix TR(6,6); // rigid arm transformation between receiver global DOFs and Master global DOFs
    FloatMatrix TMG2L(6,6); // master global to local
    FloatMatrix T(6,6); // full transformation for all dofs
    IntArray fullDofMask = {D_u, D_v, D_w, R_u, R_v, R_w};
    bool hasg2l = this->computeL2GTransformation(TG2L, fullDofMask);
    bool mhasg2l = masterNode->computeL2GTransformation(TMG2L, fullDofMask);

    xyz.beDifferenceOf(*this->giveCoordinates(), *masterNode->giveCoordinates());
    
    TR.beUnitMatrix();
    TR.at(1,5) =  xyz.at(3);
    TR.at(1,6) = -xyz.at(2);
    TR.at(2,4) = -xyz.at(3);
    TR.at(2,6) =  xyz.at(1);
    TR.at(3,4) =  xyz.at(2);
    TR.at(3,5) = -xyz.at(1);

    if (hasg2l && mhasg2l) {
      FloatMatrix h; 
      h.beTProductOf(TG2L, TR);  // T transforms global master DOfs to local dofs;
      T.beProductOf(h,TMG2L);    // Add transformation to master local c.s.
    } else if (hasg2l) {
      T.beTProductOf(TG2L, TR);  // T transforms global master DOfs to local dofs;
    } else if (mhasg2l) {
      T.beProductOf(TR,TMG2L);   // Add transformation to master local c.s.
    } else {
      T = TR;
    }
    
    // assemble DOF weights for relevant dofs
    for ( int i = 1; i <= this->dofidmask->giveSize(); i++ ) {
      Dof *dof = this->giveDofWithID(dofidmask->at(i));
      DofIDItem id = dof->giveDofID();
      masterDofID [ id ] = *dofidmask;
      masterContribution [ id ].resize(dofidmask->giveSize());
      
      for (int j = 1; j <= this->dofidmask->giveSize(); j++ ) {
        masterContribution [ id ].at(j) = T.at(id, dofidmask->at(j));
      }
    }

#endif

}
void
RigidArmNode :: computeMasterContribution()
{
    int k, sign;
    IntArray R_uvw(3), uvw(3);
    FloatArray xyz(3);
    DofIDItem id;

    // decode of masterMask
    uvw.at(1) = this->findDofWithDofId(R_u);
    uvw.at(2) = this->findDofWithDofId(R_v);
    uvw.at(3) = this->findDofWithDofId(R_w);

    for ( int i = 1; i <= 3; i++ ) {
        xyz.at(i) = this->giveCoordinate(i) - masterNode->giveCoordinate(i);
    }

    if ( hasLocalCS() ) {
        // LCS is stored as global-to-local, so LCS*xyz_glob = xyz_loc
        xyz.rotatedWith(* this->localCoordinateSystem, 'n');
    }

    for ( int i = 1; i <= numberOfDofs; i++ ) {
        id = this->giveDof(i)->giveDofID();
        R_uvw.zero();

        switch ( masterMask.at(i) ) {
        case 0: continue;
            break;
        case 1:
            if ( id == D_u ) {
                if ( uvw.at(2) && masterMask.at( uvw.at(2) ) ) {
                    R_uvw.at(3) =  ( ( int ) R_v );
                }

                if ( uvw.at(3) && masterMask.at( uvw.at(3) ) ) {
                    R_uvw.at(2) = -( ( int ) R_w );
                }
            } else if ( id == D_v ) {
                if ( uvw.at(1) && masterMask.at( uvw.at(1) ) ) {
                    R_uvw.at(3) = -( ( int ) R_u );
                }

                if ( uvw.at(3) && masterMask.at( uvw.at(3) ) ) {
                    R_uvw.at(1) =  ( ( int ) R_w );
                }
            } else if ( id == D_w ) {
                if ( uvw.at(1) && masterMask.at( uvw.at(1) ) ) {
                    R_uvw.at(2) =  ( ( int ) R_u );
                }

                if ( uvw.at(2) && masterMask.at( uvw.at(2) ) ) {
                    R_uvw.at(1) = -( ( int ) R_v );
                }
            }

            break;
        default:
            _error("computeMasterContribution: unknown value in masterMask");
        }

        k = ++ this->countOfMasterDofs->at(i);
        this->masterDofID [ i - 1 ]->at(k) = ( int ) id;
        this->masterContribution [ i - 1 ]->at(k) = 1.0;

        for ( int j = 1; j <= 3; j++ ) {
            if ( R_uvw.at(j) != 0 ) {
                sign = R_uvw.at(j) < 0 ? -1 : 1;

                k = ++ this->countOfMasterDofs->at(i);
                this->masterDofID [ i - 1 ]->at(k) = sign * R_uvw.at(j);
                this->masterContribution [ i - 1 ]->at(k) = sign * xyz.at(j);
            }
        }
    }
}
Beispiel #16
0
void MainWindow::modifieruv(){
    modifUVwindow  uvw(fac);
    if (uvw.exec()){
        fillMainWindow();
    }
}