示例#1
0
//取消选取
void DcGp::DcGpPointCloud::CancelChoosed()
{
	if (!IsChoosed())
	{
		return;
	}
	//取消每个点的选取状态
	std::fill_n(m_pDcGpPointCloudImpl->m_pointsChoosedState.begin(), Size(), false);

	//清空每个点的选取颜色
	if (HasColors() && GetColorMode() == eTrueLinearColor)
	{
		m_pDcGpPointCloudImpl->m_choosedColors = m_pDcGpPointCloudImpl->m_rgbColors;
	}
	else if (GetColorMode() == eFalseRangeColor ||
			GetColorMode() == eFalseHeightColor ||
			GetColorMode() == eFalseScalarColor)
	{
		m_pDcGpPointCloudImpl->m_choosedColors = m_pDcGpPointCloudImpl->m_scalarColors;
	}
	else
	{
		PointColor color = {GetTempColor()[0], GetTempColor()[1], GetTempColor()[2]};
		std::fill_n(m_pDcGpPointCloudImpl->m_choosedColors.begin(), Size(), color);
	}
}
示例#2
0
文件: Kruskal.cpp 项目: cty222/Note
int main(void)
{
	// Initailize testing data
	InitializeTestData ();	
	
	// Add all test data in an array
	NODE NodeArray[] = {NodeA, NodeB, NodeC, NodeD, NodeE, NodeF};
	
	//The path array count  will just have  NodeArray count minus 1.
	// Initialize Path Array.
	int PathArrayCount = GET_ARRAY_COUNT(NodeArray) -1;
	PATH ChoosedPath[PathArrayCount];
	memset (ChoosedPath, 0, sizeof(ChoosedPath));
	
	while(PathArrayCount--)
	{
		int Row = 0, Column = 0;
		
		// Initailize pointer
		PATH PtrPath;
		//PtrPath = &ChoosedPath[PathArrayCount];
		PtrPath.Distance = -1; //for checking
		
		// Double for loop for Array
		for(Row =0; Row< GET_ARRAY_COUNT(NodeArray); Row++)
		{
			NODE *Ptr = &NodeArray[Row];
			for (Column = 0; Column < Ptr->LinkCount; Column++)
			{
				// 現在的值 
				PATH TmpPath;
				TmpPath.Distance = Ptr->PtrList[Column].Distance;
				
				// 兩個Node Name 
				TmpPath.Node[0] = Ptr;
				TmpPath.Node[1] = Ptr->PtrList[Column].Node;
#if DEBUG_CLOSE				
				printf("TMP %s and %s: %d\n", TmpPath.Node[0].NodeName, TmpPath.Node[1].NodeName, TmpPath.Distance);
#endif				
				// Checking
				if (PtrPath.Distance == -1 || PtrPath.Distance> TmpPath.Distance)
				{
					if (!IsChoosed(&TmpPath, ChoosedPath, GET_ARRAY_COUNT(ChoosedPath) )
						 && !IsReturnToRoot(TmpPath.Node[1], TmpPath.Node[0], ChoosedPath, GET_ARRAY_COUNT(ChoosedPath), NULL)
						 )
				 	{
				 		PtrPath = TmpPath;
					}
				}
			}
		} 
		
		if (PtrPath.Distance != -1)
		{
			memcpy (&ChoosedPath[PathArrayCount], &PtrPath, sizeof (PATH));
			printf("===== Ans %s and %s : %d ========= \n", PtrPath.Node[0]->NodeName, PtrPath.Node[1]->NodeName, PtrPath.Distance);
		} 
		else
		{
			// Finish or error.
			break;
		}
	}
	
	FreeTestData();
	return 0;
}
示例#3
0
//绘制点云
void DcGp::DcGpPointCloud::DrawMyselfOnly(DcGpDrawContext& context)
{	
	//如果数据隐藏,则返回上层数据
	if (!IsVisible())
	{
		return;
	}

	//是否存在点数据,否则返回上层函数
	if (m_pDcGpPointCloudImpl->m_points.empty())
		return;

	//判断是否是绘制三维物体
	if (MACRO_Draw3D(context))
	{
		glPushAttrib(GL_ALL_ATTRIB_BITS);
		if (!m_pDcGpPointCloudImpl->m_generalDrawShader.getProgramIndex())
		{
			//! 初始化一个shader program,用来处理快速渲染时候点隐藏的问题
			char* byteGlVersion  = (char*)glGetString(GL_VERSION);
			if (byteGlVersion[0] < '3' )
			{
				return;
			}
			else
			{
				m_pDcGpPointCloudImpl->SetupGeneralDrawShaders();
			}

		}

		if (m_pDcGpPointCloudImpl->m_generalDrawShader.getProgramIndex())
		{
			glUseProgram(m_pDcGpPointCloudImpl->m_generalDrawShader.getProgramIndex());

			//! 为block量赋值
			double matrixProjection[16];
			double matrixView[16];
			glGetDoublev(GL_PROJECTION_MATRIX, matrixProjection);
			glGetDoublev(GL_MODELVIEW_MATRIX, matrixView);

			DCCore::mat4 matPro;
			DCCore::mat4 matView;
			for (int i = 0; i != 16; ++i)
			{
				matPro.ptr()[i] = matrixProjection[i];
				matView.ptr()[i] = matrixView[i];
			}

			DCCore::mat4 pvm = matPro * matView;

			m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("pvm", pvm.ptr());
			float isSingleColor = 0;
			m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("isSingleColor", &isSingleColor);
		}


		//获取显示参数
		glDrawParameters glParams;
		GetDrawingParameters(glParams);
		glParams.showNormals &= bool(MACRO_LightIsEnabled(context));	//是否使用光照


		//! 计算纯色值
		std::vector<float > singleColor;
		if (glParams.showColors && IsColorOverriden())
		{
			singleColor.push_back(GetTempColor()[0]);
			singleColor.push_back(GetTempColor()[1]);
			singleColor.push_back(GetTempColor()[2]);
			glParams.showColors = false;
		}
		else
		{
			singleColor.push_back(context.pointsDefaultCol[0]);
			singleColor.push_back(context.pointsDefaultCol[1]);
			singleColor.push_back(context.pointsDefaultCol[2]);
		}


		// L.O.D.
		unsigned numberOfPoints = Size();
		unsigned decimStep = 0;

		if (m_pDcGpPointCloudImpl->m_pointSize != 0)
			glPointSize((GLfloat)m_pDcGpPointCloudImpl->m_pointSize);


		//! 渲染绘制,因为为shader传入了可见性变量,所以不管什么情况只要控制传入
		//! 顶点、颜色、法向量即可。顶点是不变的,颜色是变化的(纯色、标量色、选取色),法向量是不变的(存在或者不存在)
		//!开启alpha测试
		glEnable(GL_ALPHA_TEST);
		glAlphaFunc(GL_GREATER, 0.0f);

		int sample = 0;

		

		//! 1、每帧中顶点不变
		glEnableVertexAttribArray(VSShaderLib::VERTEX_COORD_ATTRIB);
		glVertexAttribPointer(VSShaderLib::VERTEX_COORD_ATTRIB, 3, GL_FLOAT, 0, sample * 3 * sizeof(PointCoordinateType), 
			&(m_pDcGpPointCloudImpl->m_points[0][0]));

		//! 2、每帧中顶点可见性不变,传递顶点的可见性变量到shader中
		glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB1);
		glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB1, 1, GL_INT, 0, sample * 1 * sizeof(int), 
			&(m_pDcGpPointCloudImpl->m_pointsVisibility[0]));

		//! 3、确定颜色值怎么选择(只存在纯色、真彩色、标量色三种)
		if (glParams.showColors)
		{
			glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
			
			if (IsChoosed())
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_rgbColors[0][0]));
			}
		}
		else if (glParams.showScalarField) 
		{
			glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
			if (IsChoosed())
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_scalarColors[0][0]));
			}
		}
		else
		{
			if (IsChoosed())
			{
				float isSingleColor = 0;
				m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("isSingleColor", &isSingleColor);
				
				glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				//! 纯色处理,由于纯色不是颜色数组,所以采用uniform实现
				float isSingleColor = 1;
				m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("isSingleColor", &isSingleColor);

				//!传入纯色值
				m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("singleColor", &singleColor[0]);
			}
			
		}

		
		//! 渲染
		//glDrawArrays(GL_POINTS, 0, numberOfPoints);

		//绘制顶点数组时候均采用循环处理,采用数据定长处理,每次处理100000数据
		if (GetChunk() > 1)
		{
			for (long i = 0; i != GetChunk(); ++i)
			{
				if (i == GetChunk()-1)
				{
					glDrawArrays(GL_POINTS, DC_CHUNK_COUNT * i, Size() - DC_CHUNK_COUNT * i);
				}
				else
				{
					glDrawArrays(GL_POINTS, DC_CHUNK_COUNT * i, DC_CHUNK_COUNT);
				}
			}
		} 
		else
		{
			glDrawArrays(GL_POINTS, 0, Size());
		}

		glDisableVertexAttribArray(VSShaderLib::VERTEX_COORD_ATTRIB);
		glDisableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB1);
		glDisableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);

		
		glDisable(GL_ALPHA_TEST);

		
		glPopAttrib();
		glUseProgram(0);
	}
	else if (MACRO_Draw2D(context))
	{
		if (MACRO_Foreground(context) && !context.sfColorScaleToDisplay)
		{
			if (IsSfColorbarVisible()  && ScalarFieldShown())
			{
				//drawScale(context);
				AddColorBarInfo(context);
			}
		}
	}
	//绘制文本
	//context._win->Display3DLabel( "Qt", GetPoint(0) + DCVector3D(context.pickedPointsTextShift), DCColor::MAGENTA, QFont());
}
示例#4
0
void DcGp::DcGpPointCloud::FastDrawMyselfOnly(DcGpDrawContext& context)
{

	//如果数据隐藏,则返回上层数据
	if (!IsVisible())
	{
		return;
	}

	//是否存在点数据,否则返回上层函数
	if (m_pDcGpPointCloudImpl->m_points.empty())
		return;

	//判断是否是绘制三维物体
	if (MACRO_Draw3D(context))
	{
		glPushAttrib(GL_ALL_ATTRIB_BITS);
		if (!m_pDcGpPointCloudImpl->m_fastDrawShader.getProgramIndex())
		{
			//! 初始化一个shader program,用来处理快速渲染时候点隐藏的问题
			char* byteGlVersion  = (char*)glGetString(GL_VERSION);
			if (byteGlVersion[0] < '3' )
			{
				return;
			}
			else
			{
				m_pDcGpPointCloudImpl->SetupFastDrawShaders();
			}

		}

		if (m_pDcGpPointCloudImpl->m_fastDrawShader.getProgramIndex())
		{
			glUseProgram(m_pDcGpPointCloudImpl->m_fastDrawShader.getProgramIndex());

			//! 为block量赋值
			double matrixProjection[16];
			double matrixView[16];
			glGetDoublev(GL_PROJECTION_MATRIX, matrixProjection);
			glGetDoublev(GL_MODELVIEW_MATRIX, matrixView);

			DCCore::mat4 matPro;
			DCCore::mat4 matView;
			for (int i = 0; i != 16; ++i)
			{
				matPro.ptr()[i] = matrixProjection[i];
				matView.ptr()[i] = matrixView[i];
			}

			DCCore::mat4 pvm = matPro * matView;

			m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("pvm", pvm.ptr());
			float isSingleColor = 0;
			m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("isSingleColor", &isSingleColor);
		}


		//获取显示参数
		glDrawParameters glParams;
		GetDrawingParameters(glParams);
		glParams.showNormals &= bool(MACRO_LightIsEnabled(context));	//是否使用光照


		//! 计算纯色值
		std::vector<float > singleColor;
		if (glParams.showColors && IsColorOverriden())
		{
			singleColor.push_back(GetTempColor()[0]);
			singleColor.push_back(GetTempColor()[1]);
			singleColor.push_back(GetTempColor()[2]);
			glParams.showColors = false;
		}
		else
		{
			singleColor.push_back(context.pointsDefaultCol[0]);
			singleColor.push_back(context.pointsDefaultCol[1]);
			singleColor.push_back(context.pointsDefaultCol[2]);
		}


		// L.O.D.
		unsigned numberOfPoints = Size();
		unsigned sample = 1;//标准的显示全部点
		unsigned totalSamplePoints = numberOfPoints;
		if (numberOfPoints >= DCCore::MAX_FACE_NUM)
		{
			sample = static_cast<int>(ceil(static_cast<float>(numberOfPoints) / DCCore::MAX_FACE_NUM));
		}

		if (m_pDcGpPointCloudImpl->m_pointSize != 0)
			glPointSize((GLfloat)m_pDcGpPointCloudImpl->m_pointSize);


		//! 渲染绘制,因为为shader传入了可见性变量,所以不管什么情况只要控制传入
		//! 顶点、颜色、法向量即可。顶点是不变的,颜色是变化的(纯色、标量色、选取色),法向量是不变的(存在或者不存在)
		//!开启alpha测试
		glEnable(GL_ALPHA_TEST);
		glAlphaFunc(GL_GREATER, 0.0f);
		

		//! 1、每帧中顶点不变
		glEnableVertexAttribArray(VSShaderLib::VERTEX_COORD_ATTRIB);
		glVertexAttribPointer(VSShaderLib::VERTEX_COORD_ATTRIB, 3, GL_FLOAT, 0, sample * 3 * sizeof(PointCoordinateType), 
			&(m_pDcGpPointCloudImpl->m_points[0][0]));

		//! 2、每帧中顶点可见性不变,传递顶点的可见性变量到shader中
		glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB1);
		glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB1, 1, GL_INT, 0, sample * 1 * sizeof(int), 
			&(m_pDcGpPointCloudImpl->m_pointsVisibility[0]));

		//! 3、确定颜色值怎么选择(只存在纯色、真彩色、标量色三种)
		if (glParams.showColors)
		{
			glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
			
			if (IsChoosed())
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_rgbColors[0][0]));
			}
		}
		else if (glParams.showScalarField) 
		{
			glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
			if (IsChoosed())
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_scalarColors[0][0]));
			}
		}
		else
		{
			if (IsChoosed())
			{
				float isSingleColor = 0;
				m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("isSingleColor", &isSingleColor);
				
				glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				//! 纯色处理,由于纯色不是颜色数组,所以采用uniform实现
				float isSingleColor = 1;
				m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("isSingleColor", &isSingleColor);

				//!传入纯色值
				m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("singleColor", &singleColor[0]);
			}
			
		}

		
		//! 渲染
		long lodNum = Size();
		if (sample > 1)
		{
			float numFloat = static_cast<float >(lodNum) / sample;
			lodNum = static_cast<unsigned>(floor(numFloat));
		}
		glDrawArrays(GL_POINTS, 0, lodNum);


		glDisableVertexAttribArray(VSShaderLib::VERTEX_COORD_ATTRIB);
		glDisableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB1);
		glDisableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);

		
		glDisable(GL_ALPHA_TEST);

		
		glPopAttrib();
		glUseProgram(0);
	}
}