Configuración y adquisición de parámetros y funciones comunes de las cámaras industriales robóticas de Hikvision (continuamente actualizadas en lenguaje C completo)

Enterprise 2023-06-21 16:28:54 views: null

Configuración y adquisición de función de parámetro común de cámara industrial robot Hikvision (lenguaje C)

prefacio

Este artículo presenta brevemente el método de configuración y el método de adquisición de los parámetros de uso común de las cámaras industriales
Hikvision Configuración
y Si no tiene prisa, simplemente lea primero los dos blogs anteriores y podrá familiarizarse más con la composición general. del sdk de cámara industrial de Hikvision. Hay demasiados parámetros y puede actualizarlos lentamente cuando tenga tiempo...

Árbol de propiedades de la cámara

1. Control de dispositivos/Control de dispositivos

1.1 Adquisición del número de serie de la cámara/DeviceSerialNumber

	MVCC_STRINGVALUE stStrValue;
	memset(&stStrValue, 0, sizeof(MVCC_STRINGVALUE));
	nRet = MV_CC_GetStringValue(handle, "DeviceSerialNumber", &stStrValue);
	if (MV_OK != nRet)
	{
    
    
		printf("Get DeviceSerialNumber fail! nRet [0x%x]\n", nRet);
	}
	printf("Current DeviceSerialNumber [%s]\n", stStrValue.chCurValue);

resultado:
inserte la descripción de la imagen aquí

1.2 Configuración y adquisición de nombres personalizados de la cámara/ID de usuario del dispositivo

	nRet = MV_CC_SetStringValue(handle, "DeviceUserID", "UserIDChanged");
	if (MV_OK != nRet)
	{
    
    
		printf("Set DeviceUserID fail! nRet [0x%x]\n", nRet);
	}
	MVCC_STRINGVALUE stStrValue;
	memset(&stStrValue, 0, sizeof(MVCC_STRINGVALUE));
	nRet = MV_CC_GetStringValue(handle, "DeviceUserID", &stStrValue);
	if (MV_OK != nRet)
	{
    
    
		printf("Get DeviceUserID fail! nRet [0x%x]\n", nRet);
	}
	printf("Rename DeviceUserID [%s]\n", stStrValue.chCurValue);

resultado:
inserte la descripción de la imagen aquí

1.3 Adquisición del tiempo de encendido de la cámara/DeviceUptime

	MVCC_INTVALUE_EX stIntValue = {
    
    0};
    nRet = MV_CC_GetIntValueEx(handle, "DeviceUptime", &stIntValue);
    if (MV_OK != nRet)
    {
    
    
        printf("Get DeviceUptime fail! nRet [0x%x]\n", nRet);
    }
	printf("DeviceUptime [%d]\n", stIntValue.nCurValue);

resultado:
inserte la descripción de la imagen aquí

2. Control de formato de cámara/ImageFormatControl

2.1 Obtener el ancho y alto máximo de la imagen de la cámara

	MVCC_INTVALUE_EX nWidthMaxValue= = {
    
    0},nHeightMaxValue = {
    
    0};	
	//如需获取当前相机图像宽高，需要将WidthMax替换成Width	
    nRet = MV_CC_GetIntValueEx(handle, "WidthMax", &nWidthMaxValue);
    if (MV_OK != nRet)
    {
    
    
    	printf("Get WidthMax fail! nRet [0x%x]\n", nRet);
    }
    //如需获取当前相机图像宽高，需要将HeightMax替换成Height
	nRet = MV_CC_GetIntValueEx(handle, "HeightMax", &nHeightMaxValue);
    if (MV_OK != nRet)
    {
    
    
         printf("Get HeightMax fail! nRet [0x%x]\n", nRet);
    }

2.2 Establecer el área ROI de la imagen de la cámara

Nota: cuando la cámara establece el ancho y la altura de la imagen, la cámara no puede tomar la transmisión : debe configurarse antes de comenzar a capturar o después de detener la captura.

	unsigned int m_Width=1000,m_Height=1000;//要设置的步进值
	//offset，设置的偏移值，图像左上角为原点，一般需要是2的倍数，不能是奇数
	unsigned int m_OffsetX=256,m_OffsetY=256;
	//获取图像宽高最大最小值，获取步进值
	MVCC_INTVALUE_EX nWidthValue= {
    
    0},nHeightValue = {
    
    0};	
	//获取相机支持的宽高最大值	
	nRet = MV_CC_GetIntValueEx(handle, "Width", &nWidthValue);
	nRet = MV_CC_GetIntValueEx(handle, "Height", &nHeightValue);
	if(m_Width>nWidthValue.nMax||
		m_Height > nHeightValue.nMax||
		m_Width<nWidthValue.nMin||
		m_Height < nHeightValue.nMin||
		(m_Width+m_OffsetX)>nWidthValue.nMax||		//偏移值+设置值必须小于宽高的最大值
		(m_Height +m_OffsetY)>nHeightValue.nMax||)
	{
    
    
		//判断有没有超出范围，超出范围就报错！！！
		 printf("Set Image Width or Height out of range !!\n", nRet);
	}else 
	{
    
    
		//避免offset有偏移值，导致后续设置宽高失败
		nRet = MV_CC_SetIntValue(handle,"OffsetX",0);
		nRet = MV_CC_SetIntValue(handle,"OffsetY",0);
		if((m_Width%nWidthValue.nInc)==0&&(m_Height%nHeightValue.nInc)==0)//符合步进值才设置进去
		{
    
    	
			nRet = MV_CC_SetIntValue(handle,"Width",m_Width);
			if(nRet != MV_OK)
            {
    
    
               	printf("Warning: Set Width  fail nRet [0x%x]!", nRet);
            }
			nRet = MV_CC_SetIntValue(handle,"Height",m_Height);
			if(nRet != MV_OK)
            {
    
    
                printf("Warning: Set Height  fail nRet [0x%x]!", nRet);
            }
            nRet = MV_CC_SetIntValue(handle,"OffsetX",m_OffsetX);
            if(nRet != MV_OK)
            {
    
    
                printf("Warning: Set OffsetX fail nRet [0x%x]!", nRet);
            }
			nRet = MV_CC_SetIntValue(handle,"OffsetY",m_OffsetY);
			if(nRet != MV_OK)
            {
    
    
                printf("Warning: Set OffsetY fail nRet [0x%x]!", nRet);
            }
		}else
		{
    
    
			//不符合步进，减去余数再去设置宽高，此时设置的宽高与原宽高有差异
			nRet = MV_CC_SetIntValue(handle,"Width",m_Width-m_Width%nWidthValue.nInc);
			if(nRet != MV_OK)
            {
    
    
                printf("Warning: Set Width  fail nRet [0x%x]!", nRet);
            }
			nRet = MV_CC_SetIntValue(handle,"Height",m_Height-m_Height%nHeightValue.nInc);
			if(nRet != MV_OK)
            {
    
    
                printf("Warning: Set Height  fail nRet [0x%x]!", nRet);
             }
           	nRet = MV_CC_SetIntValue(handle,"OffsetX",m_OffsetX);
            if(nRet != MV_OK)
            {
    
    
                printf("Warning: Set OffsetX fail nRet [0x%x]!", nRet);
            }
			nRet = MV_CC_SetIntValue(handle,"OffsetY",m_OffsetY);
			if(nRet != MV_OK)
            {
    
    
                printf("Warning: Set OffsetY fail nRet [0x%x]!", nRet);
            }
		}		
	}

2.3 Restaurar el área ROI de la imagen de la cámara y restaurar el valor máximo

	MVCC_INTVALUE_EX nWidthMaxValue= {
    
    0},nHeightMaxValue = {
    
    0};		
	nRet = MV_CC_GetIntValueEx(handle, "WidthMax", &nWidthMaxValue);
	if (MV_OK != nRet)
	{
    
    
		printf("Get WidthMax fail! nRet [0x%x]\n", nRet);
	}
	nRet = MV_CC_GetIntValueEx(handle, "HeightMax", &nHeightMaxValue);
	if (MV_OK != nRet)
	{
    
    
		printf("Get HeightMax fail! nRet [0x%x]\n", nRet);
	}	
	//一定要先还原相机的偏移值，再去设置相机宽高
	nRet = MV_CC_SetIntValue(handle,"OffsetX",0);
	nRet = MV_CC_SetIntValue(handle,"OffsetY",0);
	nRet = MV_CC_SetIntValue(handle,"Width",nWidthMaxValue.nCurValue);//设置为最大值
	if(nRet != MV_OK)
	{
    
    
		printf("Warning: Set Width  fail nRet [0x%x]!", nRet);
	}
	nRet = MV_CC_SetIntValue(handle,"Height",nHeightMaxValue.nCurValue);//设置为最大值
	if(nRet != MV_OK)
	{
    
    
		printf("Warning: Set Height  fail nRet [0x%x]!", nRet);
	}

2.4 Obtener el formato de imagen compatible con la cámara

MV_XML_NODE_FEATURE stNodeFeature;
MV_XML_FEATURE_Enumeration stFeatureEnm;
memset(&stNodeFeature,0,sizeof(MV_XML_NODE_FEATURE));
memset(&stFeatureEnm, 0, sizeof(MV_XML_FEATURE_Enumeration));
strncpy(stNodeFeature.strName, "PixelFormat", strlen("PixelFormat"));
stNodeFeature.enType = IFT_IEnumeration;
nRet = MV_XML_GetNodeFeature(handle,&stNodeFeature,&stFeatureEnm);
if (MV_OK != nRet)
{
    
    
	return nRet;
}else
{
    
    
	for (int i = 0; i < stFeatureEnm.nSymbolicNum; i++)
	{
    
    
		printf("PixelFormat:%s \r\n", stFeatureEnm.strSymbolic[i]);//打印出相机支持的所有像素格式
				
	}
	for (int i = 0; i < stFeatureEnm.nSymbolicNum; i++)
	{
    
    
		if (strcmp(stFeatureEnm.strSymbolic[i] ,"BayerBG8")==0|| 
			strcmp(stFeatureEnm.strSymbolic[i], "BayerRG8")==0|| 
			strcmp(stFeatureEnm.strSymbolic[i], "BayerGB8")==0|| 
			strcmp(stFeatureEnm.strSymbolic[i], "BayerGR8")==0||
			strcmp(stFeatureEnm.strSymbolic[i], "RGB8Packed")==0|| 
			strcmp(stFeatureEnm.strSymbolic[i], "BGR8Packed")==0)//比较相机参数格式，这里仅比较了bayer与RGB
		{
    
    
			printf("This is a Color camera \n");
			break;
		}
	}
}

resultado:
Cámara en blanco y negro: ![insertar descripción de la imagen aquí](https://img-blog.csdnimg.cn/81aa4d9a473442bcb28dc8114137f7c9.png) Cámara a color:

2.5 Modificar el formato de imagen de la cámara

	//设置Enum型参数-相机图像格式
	//注意点1：相机图像格式设置时，只有在MV_CC_Startgrab接口调用前才能设置,取流过程中，不能修改图像格式
	nRet = MV_CC_SetEnumValue(handle, "PixelFormat", PixelType_Gvsp_Mono12);
	if (MV_OK != nRet)
	{
    
    
		printf("error: Set PixelFormat fail [%x]\n", nRet);
	}

2.6 Activar/desactivar la imagen de prueba integrada de la cámara

2.6.1 Apagar la imagen de prueba (estado predeterminado)

	nRet = MV_CC_SetEnumValue(handle, "TestPattern", 0);
	if (MV_OK != nRet)
	{
    
    
		printf("Set TestPattern fail! nRet [0x%x]\n", nRet);
		break;
	}

2.6.2 Abrir la imagen de prueba

	nRet = MV_CC_SetEnumValue(handle, "TestPattern", 9);
	//0:off,9:ColorBar,14:ObliqueMonoBar,17:TestImage1
	if (MV_OK != nRet)
	{
    
    
		printf("Set TestPattern fail! nRet [0x%x]\n", nRet);
		break;
	}

Efecto:
inserte la descripción de la imagen aquí

2.7 Activar/desactivar la imagen de la cámara espejo X, espejo Y

	nRet = MV_CC_SetBoolValue(handle, "ReverseX", true);
	if (MV_OK != nRet)
	{
    
    
		printf("Set ReverseX fail! nRet [0x%x]\n", nRet);
	}
	//Y镜像需要注意两点
	//1.部分相机不支持，所以可能设置不了，具体看相机规格书spec
	//2.Y镜像需要停止采集状态下设置，不像X镜像一样可以实时设置，一般在MV_CC_StartGrabbing接口之前调用
	nRet = MV_CC_SetBoolValue(handle, "ReverseY", true);
	if (MV_OK != nRet)
	{
    
    
		printf("Set ReverseY fail! nRet [0x%x]\n", nRet);
	}

Efecto:
inserte la descripción de la imagen aquí

2.8 Activar/desactivar la función de marca de agua de la imagen incrustada en la cámara

La información de la marca de agua de la imagen de la cámara se utiliza para imprimir y grabar la información interna de la cámara. La información de la marca de agua se encuentra en la interfaz de transmisión. El principio
esencial para obtener la marca de agua de la cámara en la estructura de la imagen es reemplazar una pequeña parte de la información a partir del encabezado de la imagen, que ocupa unos 40 bytes Información de datos reales para la transmisión de información sin causar cambios en el tamaño de los datos de la imagen
inserte la descripción de la imagen aquí

parámetro Palabras clave valor del parámetro
marca de tiempo marca de tiempo 0
ganar Ganar 1
exposición Exposición 2
brillo promedio Información de brillo 3
balance de blancos Balance de blancos 4
número de cuadro Contador de fotogramas 5
contador de disparos ExtTriggerCount 6
Estado del nivel de entrada y salida de E/S LíneaEntradaSalida 7
área de rendimiento de la inversión ROIPosición 8 
	//必须停止采集状态下设置，一般在MV_CC_StartGrabbing接口之前调用
	//开启相机图像水印，如下，打开了Exposure、BrightnessInfo、Framecounter
	nRet = MV_CC_SetEnumValue(handle, "FrameSpecInfoSelector", 2);//Exposure
	nRet = MV_CC_SetBoolValue(handle, "FrameSpecInfo", true);
	nRet = MV_CC_SetEnumValue(handle, "FrameSpecInfoSelector", 3);//BrightnessInfo
	nRet = MV_CC_SetBoolValue(handle, "FrameSpecInfo", true);
	nRet = MV_CC_SetEnumValue(handle, "FrameSpecInfoSelector", 5);//Framecounter
	nRet = MV_CC_SetBoolValue(handle, "FrameSpecInfo", true);
	if (MV_OK != nRet)
	{
    
    
		printf("Set FrameSpecInfofail! nRet [0x%x]\n", nRet);
	}

Efecto:
en el proceso de búsqueda activa de la transmisión, la información de la marca de agua se obtiene de la estructura de la imagen y
inserte la descripción de la imagen aquí
la función de marca de agua se desactiva

	//必须停止采集状态下设置，一般在MV_CC_StartGrabbing接口之前调用
	nRet = MV_CC_SetEnumValue(handle, "FrameSpecInfoSelector", 5);//Framecounter
	nRet = MV_CC_SetBoolValue(handle, "FrameSpecInfo", false);

3. Control de Adquisición/Control de Adquisición

3.1 Configuración del modo de recopilación

parámetro Palabras clave valor del parámetro ilustrar
adquisición de un solo cuadro Un solo cuadro 0 Generalmente se usa para software especial como visionpro, y no se recomienda usar este modo normalmente.
adquisición continua Continuo 2 Modos de uso común, adquisición de un solo cuadro de disparo suave, adquisición de disparo duro, toma continua de fotos, todos usan este modo 
	nRet = MV_CC_SetEnumValue(handle, "AcquisitionMode", 2);
	if (MV_OK != nRet)
	{
    
    
		printf("Set FrameSpecInfofail! nRet [0x%x]\n", nRet);
	}

3.2 Configuración de adquisición de múltiples fotogramas/AcquisitionBurstFrameCount

AcquisitionBurstFrameCount: en el modo de disparo, cuántos fotogramas se adquieren una vez activados, el valor predeterminado es 1;
si se establece en 2, la cámara recibe una señal y adquiere automáticamente dos fotogramas, y la frecuencia de adquisición cambia según la velocidad de fotogramas

	nRet = MV_CC_SetIntValue(handle,"AcquisitionBurstFrameCount",1);
	if(nRet != MV_OK)
	{
    
    
		printf("Warning: Set AcquisitionBurstFrameCountfail nRet [0x%x]!", nRet);
	}

3.3 Control de velocidad de fotogramas/AdquisiciónFrameRate

	//设置相机帧率，需注意不要超过相机支持的最大的帧率（相机规格书），超过了也没有意义
	nRet =MV_CC_SetFloatValue(handle, "AcquisitionFrameRate", 5);
	if(nRet != MV_OK)
	{
    
    
		printf("Warning: Set AcquisitionBurstFrameCountfail nRet [0x%x]!", nRet);
	}
	//帧率控制使能，true表示打开，false标识关闭
	nRet = MV_CC_SetBoolValue(handle, "AcquisitionFrameRateEnable", true);
	if(nRet != MV_OK)
	{
    
    
		printf("Warning: Set AcquisitionBurstFrameCountfail nRet [0x%x]!", nRet);
	}

3.4 Configuración del modo de disparo

3.4.1 Configuración de disparador suave/Software

	// ch:设置触发模式为on 
	nRet = MV_CC_SetEnumValue(handle, "TriggerMode", MV_TRIGGER_MODE_ON);
	if (MV_OK != nRet)
	{
    
    
		printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);
	}
	// ch:设置触发源为软触发
	nRet = MV_CC_SetEnumValue(handle, "TriggerSource",MV_TRIGGER_SOURCE_SOFTWARE);//TriggerSource：7
	if (MV_OK != nRet)
	{
    
    
		printf("Set Trigger Source fail! nRet [0x%x]\n", nRet);
	}

Cuando necesite tomar una foto, ejecute el comando de comando, ejecútelo una vez y la cámara tomará una foto (solo funcionará después de que se habilite el comando de inicio de captura)

	nRet = MV_CC_SetCommandValue(handle, "TriggerSoftware");//相机拍照
	if (MV_OK != nRet)
	{
    
    
		printf("TriggerSoftware fail! nRet [0x%x]\n", nRet);
	}

3.4.2 Configuración/línea de activación dura

El disparador duro debe coincidir con el cableado del disparador duro, y hay muchos parámetros coincidentes Consulte: Módulo de función de cámara industrial Hikvision-Control de entrada y salida IO
Incluyendo:
1. Modo de disparo: TriggerMode está configurado en 1, el modo de disparo es activado
2. Selección de la fuente de disparo: TriggerSource Establézcalo en 0, elija la línea 0, también puede elegir la línea 2 o elegir de todos modos, la línea 0 y la línea 2 dependen del cableado del circuito de hardware, de todos modos es compatible con el disparador suave y el disparador duro al mismo tiempo, depende de si la cámara admite 3. Señal de borde TriggerActivation:
disparador de borde ascendente predeterminado (no se puede configurar)
4. Caché de disparador TriggerCacheEnable: Deshabilitado de forma predeterminada. Cuando la cámara recibe dos señales de activación al mismo tiempo, si esta función no está activada, la cámara solo responderá a una señal y producirá una imagen; después de encenderla, la cámara almacenará automáticamente en caché la segunda señal y procesará inmediatamente después de que se procese la señal anterior Señal de búfer 5. Retardo del disparador Retardo del disparador
: después de recibir la señal, un retardo fijo por un período de tiempo antes de la exposición

	// ch:设置触发模式为on 
	nRet = MV_CC_SetEnumValue(handle, "TriggerMode", MV_TRIGGER_MODE_ON);
	if (MV_OK != nRet)
	{
    
    
		printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);
	}
	// ch:设置触发源为line硬触发
	nRet = MV_CC_SetEnumValue(handle, "TriggerSource",MV_TRIGGER_SOURCE_LINE0);//line0：0，line2：2
	if (MV_OK != nRet)
	{
    
    
		printf("Set Trigger Source fail! nRet [0x%x]\n", nRet);
	}

3.4.3 Configuración de disparador arbitraria/De todos modos

De todos modos, la cámara puede responder a los comandos de activación suaves y también puede responder a las señales de activación duras de línea 0 y línea 2.
Tenga en cuenta que cuando necesite usar esta función, debe saber si la cámara es compatible con esta función.

	// ch:设置触发模式为on 
	nRet = MV_CC_SetEnumValue(handle, "TriggerMode", MV_TRIGGER_MODE_ON);
	if (MV_OK != nRet)
	{
    
    
		printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);
	}
	// ch:设置触发源为anyway
	nRet = MV_CC_SetEnumValue(handle, "TriggerSource",24);//line0：0，line2：2，anyway：24
	if (MV_OK != nRet)
	{
    
    
		printf("Set Trigger Source fail! nRet [0x%x]\n", nRet);
	}

3.5 Ajustes de exposición

3.5.1 Ajuste de exposición manual

	nRet = MV_CC_SetEnumValue(handle, "ExposureMode",0);//0：Timed
	nRet = MV_CC_SetFloatValue(handle, "ExposureTime", 1000);
	if (MV_OK != nRet)
	{
    
    
		printf("Set ExposureTime fail nRet [0xd%]\n!", nRet);
	}

3.5.2 Configuración de exposición automática

	nRet = MV_CC_SetEnumValue(handle, "ExposureMode",0);//0：Timed
	//ExposureAuto
	nRet = MV_CC_SetFloatValue(handle, "ExposureAuto", 2);//0：off 1：once 2：Continuous
	if (MV_OK != nRet)
	{
    
    
		printf("Set ExposureAuto fail nRet [0xd%]\n!", nRet);
	}else{
    
    
		//只有自动曝光或者自动增益开启后，Brightness亮度值方可设置
		nRet = MV_CC_SetIntValue(handle,"Brightness",160);
		if(nRet != MV_OK)
		{
    
    
			printf("Set BrightnessnRet [0x%x]!", nRet);
		}
	}

3.5.3 Configuración de exposición ultracorta

		//标准曝光模式
		nRet = MV_CC_SetEnumValue(handle, "ExposureMode",0);//0：Timed
		nRet = MV_CC_SetEnumValue(handle, "ExposureTimeMode", 0);//0：Standard，1：UltraShort
        if (MV_OK != nRet)
        {
    
    
            printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);
        }else
		{
    
    
			printf("ExposureTimeMode :Standard\n");
			//需要注意曝光值范围
			nRet = MV_CC_SetFloatValue(handle, "ExposureTime", 1000);
			if (MV_OK != nRet)
			{
    
    
				printf("Set ExposureTime fail nRet [0xd%]\n!", nRet);
			}
		}
		//超短曝光模式
		nRet = MV_CC_SetEnumValue(handle, "ExposureTimeMode", 1);//0：standard，1：UltraShort
        if (MV_OK != nRet)
        {
    
    
            printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);
        }else
		{
    
    
			printf("ExposureTimeMode :UltraShort\n");
			//需要注意曝光值范围
			nRet = MV_CC_SetFloatValue(handle, "ExposureTime", 12);
			if (MV_OK != nRet)
			{
    
    
				printf("Set ExposureTime fail nRet [0xd%]\n!", nRet);
			}
		}

Cambio de ganancia de exposición múltiple 3.6 HDR

	unsigned ExpValue[4]={
    
    2000,3000,2500,1300};
	unsigned GainValue[4]={
    
    0,1,2,3};
	for (int i = 0; i < 4; i++)
	{
    
    
		nRet = MV_CC_SetIntValue(handle,"HDRSelector",i);//设置为最大值
		if(nRet != MV_OK)
		{
    
    
			printf("Warning: Set HDRSelector  fail nRet [0x%x]!", nRet);
		}
		nRet = MV_CC_SetIntValue(handle,"HDRShutter",ExpValue[i]);//设置为最大值
		if(nRet != MV_OK)
		{
    
    
			printf("Warning: Set HDRShutter  fail nRet [0x%x]!", nRet);
		}
		nRet =MV_CC_SetFloatValue(handle, "HDRGain", GainValue[i]);
		if(nRet != MV_OK)
		{
    
    
			printf("Warning: Set HDRGain nRet [0x%x]!", nRet);
		}
	}

4. Control analógico/Control analógico

4.1 Configuración de ganancia analógica

	nRet = MV_CC_SetFloatValue(handle, "Gain", 1;
	if (MV_OK != nRet)
	{
    
    
		printf("Set Gainfail fail nRet [0xd%]\n", nRet);
	}

4.2 Ajuste de ganancia digital

	//打开数字增益使能
	nRet = MV_CC_SetBoolValue(handle, "DigitalShiftEnable", true);
	if (MV_OK != nRet)
	{
    
    
		printf("Set DigitalShiftEnable fail! nRet [0x%x]\n", nRet);
	}
	//设置数字增益，范围-6~6db
	nRet = MV_CC_SetFloatValue(handle, "DigitalShift", 1);
	if (MV_OK != nRet)
	{
    
    
		printf("Set DigitalShift fail !nRet [0xd%]\n", nRet);
	}

4.3 Configuración de gamma/Gamma

	//1.打开数字增益使能
	nRet = MV_CC_SetBoolValue(handle, "GammaEnable", true);
	if (MV_OK != nRet)
	{
    
    
		printf("Set GammaEnable fail! nRet [0x%x]\n", nRet);
	}
	//2.设置gamma类型，user：1，sRGB：2
	nRet = MV_CC_SetEnumValue(handle, "GammaSelector", 1);
	if (MV_OK != nRet)
	{
    
    
		printf("Set GammaSelector fail! nRet [0x%x]\n", nRet);
	}
	//3.设置gamma值，推荐范围0.5-2，1为线性拉伸
	nRet = MV_CC_SetFloatValue(handle, "Gamma", 1);
	if (MV_OK != nRet)
	{
    
    
		printf("Set Gamma failed! nRet [0xd%]\n", nRet);
	}

4.4 Ajuste de nitidez/Nitidez

4.4.1 Ajustes de nitidez de la cámara

El procesamiento interno de la cámara industrial admite la configuración de nitidez (procesamiento ISP del hardware de la cámara).
La nitidez debe prestar atención al formato de imagen de la cámara. Por ejemplo, YUV, RGB, MONO10, MONO12 y otros formatos no admiten nitidez, por lo que necesita ser realizado por otros métodos

	//打开锐度使能
	nRet = MV_CC_SetBoolValue(handle, "SharpnessEnable", true);
	if (MV_OK != nRet)
	{
    
    
		printf("Set SharpnessEnable failed! nRet [0x%x]\n", nRet);
	}
	//设置锐度，范围0-100
	nRet = MV_CC_SetFloatValue(handle, "Sharpness", 1);
	if (MV_OK != nRet)
	{
    
    
		printf("Set Sharpness failed nRet [0xd%]\n", nRet);
	}

4.4.2 Ajustes de nitidez del SDK

Cuando el hardware de la cámara no es compatible con el procesamiento de nitidez en algunos casos, Hikvision SDK proporciona una llamada de interfaz de nitidez a nivel de software.
Solo se admiten el formato mono8 y el formato RGB. Otros formatos de imagen deben convertirse primero a estos dos formatos.

static  unsigned int __stdcall WorkThread(void* pUser)
{
    
    
    int nRet = MV_OK;
	unsigned char *pConvertData = NULL;
	unsigned char *pSharpenData = NULL;
    unsigned int nConvertDataSize = 0;
    MV_FRAME_OUT stImageInfo = {
    
    0};					//图像帧信息结构体
    MV_DISPLAY_FRAME_INFO stDisplayInfo = {
    
    0};		//用于显示的
	MV_CC_PIXEL_CONVERT_PARAM stConvertParam = {
    
    0}; //用于格式转化的
	MV_CC_SHARPEN_PARAM stSharpenParam ={
    
    0};	    //用于锐度的
    while(1)
    {
    
    
        nRet = MV_CC_GetImageBuffer(pUser, &stImageInfo, 1000);//取一帧图像
        if (nRet == MV_OK)
        {
    
    
            printf("Get Image Buffer: Width[%d], Height[%d], FrameNum[%d]\n", 
                stImageInfo.stFrameInfo.nWidth, stImageInfo.stFrameInfo.nHeight, stImageInfo.stFrameInfo.nFrameNum);
			MvGvspPixelType enDstPixelType = PixelType_Gvsp_Undefined;
            unsigned int nChannelNum = 0;//用于判断图像通道数
            char chFileName[MAX_PATH] = {
    
    0};
            //如果是彩色则转成RGB8
            //isColor，isMono函数，看相机图像格式介绍章节
            if (IsColor(stImageInfo.stFrameInfo.enPixelType))//判断相机图像原始数据格式是什么
            {
    
    
                nChannelNum = 3;
                enDstPixelType = PixelType_Gvsp_RGB8_Packed;
                sprintf(chFileName, "AfterConvert.rgb");
            }
            //如果是黑白则转换成Mono8
            else if (IsMono(stImageInfo.stFrameInfo.enPixelType))
            {
    
    
                nChannelNum = 1;
                enDstPixelType = PixelType_Gvsp_Mono8;
                sprintf(chFileName, "AfterConvert.gray");
            }
            else
            {
    
    
                printf("Don't need to convert!\n");
            }
            if (enDstPixelType != PixelType_Gvsp_Undefined)
            {
    
    
				if (NULL == pConvertData)
				{
    
    
				//分配一块区域用于格式转化
					pConvertData = (unsigned char*)malloc(stImageInfo.stFrameInfo.nWidth * stImageInfo.stFrameInfo.nHeight * nChannelNum);
					if (NULL == pConvertData)
					{
    
    
						printf("malloc pConvertData fail!\n");
						nRet = MV_E_RESOURCE;
						break;
					}
				}                  
                nConvertDataSize = stImageInfo.stFrameInfo.nWidth * stImageInfo.stFrameInfo.nHeight * nChannelNum;
                // ch:像素格式转换 | en:Convert pixel format 
              
                stConvertParam.nWidth = stImageInfo.stFrameInfo.nWidth;                 //ch:图像宽 | en:image width
                stConvertParam.nHeight = stImageInfo.stFrameInfo.nHeight;               //ch:图像高 | en:image height
                stConvertParam.pSrcData = stImageInfo.pBufAddr;                         //ch:输入数据缓存 | en:input data buffer
                stConvertParam.nSrcDataLen = stImageInfo.stFrameInfo.nFrameLen;         //ch:输入数据大小 | en:input data size
                stConvertParam.enSrcPixelType = stImageInfo.stFrameInfo.enPixelType;    //ch:输入像素格式 | en:input pixel format
                stConvertParam.enDstPixelType = enDstPixelType;                         //ch:输出像素格式 | en:output pixel format
                stConvertParam.pDstBuffer = pConvertData;                               //ch:输出数据缓存 | en:output data buffer
                stConvertParam.nDstBufferSize = nConvertDataSize;                       //ch:输出缓存大小 | en:output buffer size
                nRet = MV_CC_ConvertPixelType(pUser, &stConvertParam);//图像格式转化
                if (MV_OK != nRet)
                {
    
    
                    printf("Convert Pixel Type fail! nRet [0x%x]\n", nRet);
                    break;
				}else
				{
    
    
					 printf("Convert Pixel Type ok!\n");
				}		
			}
			if(g_Sharpen)//全局变量，用于判断要不要做锐化
			{
    
    
				if (NULL == pSharpenData)
				{
    
    
					pSharpenData = (unsigned char*)malloc(stImageInfo.stFrameInfo.nWidth * stImageInfo.stFrameInfo.nHeight * nChannelNum);
					if (NULL == pSharpenData)
					{
    
    
						printf("malloc pConvertData fail!\n");
						nRet = MV_E_RESOURCE;
						break;
					}
				}
				stSharpenParam.nWidth = stImageInfo.stFrameInfo.nWidth;
				stSharpenParam.nHeight = stImageInfo.stFrameInfo.nHeight;
				stSharpenParam.enPixelType = enDstPixelType;				//像素格式变化,用转化后的图像格式传入
				stSharpenParam.pSrcBuf = stConvertParam.pDstBuffer;			//输入
				stSharpenParam.nSrcBufLen = stConvertParam.nDstBufferSize;//数据大小变化
				stSharpenParam.pDstBuf = pSharpenData;						//输出，后续处理要用这个数据啦
				stSharpenParam.nDstBufSize = stConvertParam.nDstBufferSize;	//数据大小变化
				stSharpenParam.nSharpenAmount = m_nSharpenAmount;
				stSharpenParam.nSharpenRadius = m_nSharpenRadius;
				stSharpenParam.nSharpenThreshold = m_nSharpenThreshold;
				nRet = MV_CC_ImageSharpen(pUser, &stSharpenParam);
				if (MV_OK != nRet)
				{
    
    
					printf("Image Sharpen fail! nRet [0x%x]\n", nRet);
					break;
				}else
				{
    
    
					 printf("Sharpen :50 ok!\n");
				}
			}
			T2=qMyMilliseconds();//计时函数，可以删除
			printf("Grab ok!，costtime：%f\n",T2-T1);
            if (g_hwnd)
            {
    
    
                stDisplayInfo.hWnd = g_hwnd;
                stDisplayInfo.pData = pSharpenData;
                stDisplayInfo.nDataLen = nConvertDataSize;
                stDisplayInfo.nWidth = stImageInfo.stFrameInfo.nWidth;
                stDisplayInfo.nHeight = stImageInfo.stFrameInfo.nHeight;
                stDisplayInfo.enPixelType = enDstPixelType;//像素格式变化
                nRet =MV_CC_DisplayOneFrame(pUser, &stDisplayInfo);
            }
			MV_SAVE_IMG_TO_FILE_PARAM stSaveFileParam;//存图测试，可以删除，不调用
			memset(&stSaveFileParam, 0, sizeof(MV_SAVE_IMG_TO_FILE_PARAM));
			stSaveFileParam.enImageType = MV_Image_Bmp; // ch:需要保存的图像类型 | en:Image format to save
			stSaveFileParam.enPixelType = enDstPixelType;  // ch:相机对应的像素格式 | en:Camera pixel type
			stSaveFileParam.nWidth      = stImageInfo.stFrameInfo.nWidth;         // ch:相机对应的宽 | en:Width
			stSaveFileParam.nHeight     = stImageInfo.stFrameInfo.nHeight;          // ch:相机对应的高 | en:Height
			stSaveFileParam.nDataLen    = nConvertDataSize;
			stSaveFileParam.pData       = pSharpenData;
			stSaveFileParam.iMethodValue = 0;
			 // ch:jpg图像质量范围为(50-99], png图像质量范围为[0-9] | en:jpg image nQuality range is (50-99], png image nQuality range is [0-9]
			if (MV_Image_Bmp == stSaveFileParam.enImageType)
			{
    
    
				sprintf_s(stSaveFileParam.pImagePath, 256, "Image_w%d_h%d_fn%03d_%d_%d_%d.bmp", stSaveFileParam.nWidth, stSaveFileParam.nHeight, stImageInfo.stFrameInfo.nFrameNum,m_nSharpenAmount,m_nSharpenAmount,m_nSharpenThreshold);
			}
			nRet = MV_CC_SaveImageToFile(pUser,&stSaveFileParam);
			if(nRet != MV_OK)
            {
    
    
                printf("MV_CC_SaveImageToFile fail! nRet [0x%x]\n", nRet);
            }else
				{
    
    
					 printf("MV_CC_SaveImageToFile  ok!\n");
				}

            nRet = MV_CC_FreeImageBuffer(pUser, &stImageInfo);
            if(nRet != MV_OK)
            {
    
    
                printf("Free Image Buffer fail! nRet [0x%x]\n", nRet);
            }
        }
        else
        {
    
    
            //printf("Get Image fail! nRet [0x%x]\n", nRet);
        }
        if(g_bExit)
        {
    
    
            break;
        }
    }

    return 0;
}

4.5 Configuración del balance de blancos/BalanceBlancoAuto

4.5.1 Balance de blancos automático

	//开启自动白平衡
	nRet = MV_CC_SetEnumValue(handle, "BalanceWhiteAuto", 1);
	if (MV_OK != nRet)
	{
    
    
		printf("Set BalanceWhiteAuto  fail! nRet [0x%x]\n", nRet);
	}
	//取流之后，自动白平衡采集一段时间，相机自动调整
	//调整完毕后后，关闭自动白平衡，即可
	sleep(2000);
	//关闭自动白平衡
	nRet = MV_CC_SetEnumValue(handle, "BalanceWhiteAuto", 0);
	if (MV_OK != nRet)
	{
    
    
		printf("Set BalanceWhiteAuto  fail! nRet [0x%x]\n", nRet);
	}

4.5.2 Balance de blancos manual

	//关闭自动白平衡
	nRet = MV_CC_SetEnumValue(handle, "BalanceWhiteAuto", 0);
	if (MV_OK != nRet)
	{
    
    
		printf("Set BalanceWhiteAuto  fail! nRet [0x%x]\n", nRet);
		break;
	}
	//手动白平衡设置
	int BalanceRatio_Value[3]={
    
    1100,1024,1800};//R、G、B
	for (int i = 0; i < 3; i++)
	{
    
    
		nRet = MV_CC_SetEnumValue(handle, "BalanceRatioSelector", i);
		nRet = MV_CC_SetIntValue(handle, "BalanceRatio",BalanceRatio_Value[i]);
	}

5. Control de E/S digital/Control de E/S digital

Control de salida 5.1IO

El control de E/S de la cámara se utiliza principalmente para controlar la salida de señal de E/S Para obtener más información, consulte la parte de salida de E/S del artículo: Módulo de función de cámara industrial Hikvision-Control de entrada y salida de E/S

5.2 Introducción a la salida IO y los eventos de salida

La salida IO también puede ser controlada por la cámara. En diferentes períodos de tiempo cuando la cámara funciona, se proporciona una señal de salida para controlar dispositivos externos. Los eventos IO admitidos por las cámaras industriales Hikvision incluyen lo siguiente:

nombre de la fuente del evento Palabras clave valor del parámetro Función descriptiva
inicio de exposición ExposiciónStartActive 0 Cuando el sensor comienza a exponerse, la señal de salida
comienzo de la colección AcquisitionStartActive 1 Señal de salida cuando comienza la lectura de datos, tiempo de inicio de lectura de cuadros
fin de colección AdquisiciónStopActive 2 Señal de salida al final de la lectura de datos, hora de finalización de la lectura de cuadros
Comienzo de la trama FrameBurstStartActivo 3 La señal se emite cuando los datos de la imagen comienzan a enviarse a través del enlace, y la señal se emite solo cuando brust> 2, lo que a menudo es inútil
final del dibujo MarcoRáfagaFinActivo 4 Cuando los datos de la imagen se envían a través del enlace, la señal se emite al final del enlace y la señal se emite solo cuando brust> 2, lo que a menudo es inútil
salida de disparo suave SoftTriggerActivo 5 El software llama al comando tiempo de comando, la salida, el usuario puede controlarlo de forma independiente
salida de disparo duro HardTriggerActivo 6 Cuando la señal de entrada de la cámara line0\2 recibe la señal de entrada, emite una señal de salida
salida de contador TemporizadorActivo 7 Temporizador, calcule el número de señales especificadas recibidas por line0 y line2, y emita una señal de salida
desencadenar la salida de espera MarcoDisparadorEsperar 8 La cámara se puede activar, y cuando se recopila la exposición, la señal de activación

Los más utilizados son el inicio de la exposición, la salida del disparador suave y la salida del disparador duro
. Por ejemplo:

	//参数初始化
	nRet = MV_CC_SetEnumValue(handle, "LineSelector", 2);	//选择对应的硬件输出源
	//0:Line0 1:Line1 2:Line2 
	nRet = MV_CC_SetEnumValue(handle, "LineMode", 8);		//仅line2需要设置
	//0:Input 1:Output 8:Strobe 
	nRet = MV_CC_SetEnumValue(handle, "LineSource", 5);
	//0:ExposureStartActive 5:SoftTriggerActive  6:HardTriggerActive
	int DurationValue=1000,DelayValue=100,PreDelayValue=0;//us
	nRet = MV_CC_SetIntValue(handle, "StrobeLineDuration",DurationValue);//脉宽持续时间
	nRet = MV_CC_SetIntValue(handle, "StrobeLineDelay",DelayValue);//strobe延时，从曝光开始，延时多久输出
	nRet = MV_CC_SetIntValue(handle, "StrobeLinePreDelay",PreDelayValue);//strobe提前输出，曝光延后开始
	nRet = MV_CC_SetBoolValue(handle, "StrobeEnable",TRUE);
//Strobe输出使能，使能之后，上面配置参数生效，IO输出与LineSource同步
//-------------------------------------------------------------------------------------
//输出IO信号命令，需要时，调用此行代码，相机通过line2输出一个周期1100us的方波，有效脉宽1000us
nRet = MV_CC_SetCommandValue(m_handle, "LineTriggerSoftware");

6. Control de Comando de Acción/Control de Acción

7. Control de acceso a archivos/Control de acceso a archivos

8. Supervisión de eventos/Control de eventos

8.1 Hora de finalización de la exposición

9. Control de bloques de datos/ChunkDataControl

10. Control de capa de transporte / TransportLayerControl

10.1 Configuración del tiempo de latido

//mv_cc_Opendevice之后调用
//推荐值3000-60000ms，不建议低于3000ms，容易掉线
nRet = MV_CC_SetIntValue(handle,"GevHeartbeatTimeout",3000);//单位ms
if(nRet != MV_OK)
{
    
    
	printf("Warning: Set Width  fail nRet [0x%x]!", nRet);
}

11. Control de configuración de usuario/Control de configuración de usuario

11.1 Guardar parámetros en la cámara

Guarde los parámetros en el conjunto de usuario para asegurarse de que los parámetros no desaparezcan después de apagar la cámara.

//初始化部分，放在Opendevice之后即可
nRet = MV_CC_SetEnumValue(handle, "UserSetSelector", 1);//支持1、2、3组，3组不同参数保存
if (MV_OK != nRet)
{
    
    
	printf("error: SetEnumValue UserSetSelector fail [%x]\n", nRet);
}
nRet = MV_CC_SetEnumValue(handle, "UserSetDefault", 1);//选择上电后，默认加载那一组参数
if (MV_OK != nRet)
{
    
    
	printf("error: SetEnumValue UserSetDefault fail [%x]\n", nRet);
}

//大部分参数修改完成后，调用此命令进行保存，不建议频繁调用
nRet = MV_CC_SetCommandValue(m_handle, "UserSetSave");//保存命令
if (MV_OK != nRet)
{
    
    
	printf("error: SetCommandValue fail [%x]\n", nRet);
}

11.2 Restaurar parámetros predeterminados de fábrica

//相机停止采集后才能调用
nRet = MV_CC_SetEnumValue(handle, "UserSetSelector", 0);//1、2、3是用户自己保存的参数，0是相机出厂参数
if (MV_OK != nRet)
{
    
    
	printf("error: SetEnumValue UserSetSelector fail [%x]\n", nRet);
}
nRet = MV_CC_SetCommandValue(m_handle, "UserSetLoad");//加载0组参数
if (MV_OK != nRet)
{
    
    
	printf("error: SetCommandValue fail [%x]\n", nRet);
}

Supongo que te gusta

Origin blog.csdn.net/qq_23107577/article/details/121077409
Recomendado
Clasificación
Diario
Más
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)

Code World

© 2018 codetd.com