Réglage et acquisition des paramètres et fonctions communs des caméras industrielles robotisées Hikvision (mises à jour en continu en langage C complet)

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

Réglage et acquisition de la fonction de paramètre commun de la caméra industrielle du robot Hikvision (langage C)

avant-propos

Cet article présente brièvement la méthode de réglage et la méthode d'acquisition des paramètres couramment utilisés des caméras industrielles
Hikvision . Réglage Si vous n'êtes pas pressé, lisez simplement les deux blogs ci-dessus en premier, et vous pourrez vous familiariser avec la composition globale du sdk de la caméra industrielle de Hikvision. Il y a trop de paramètres, et vous pouvez les mettre à jour lentement quand vous avez le temps...


Arbre des propriétés de la caméra

1. Contrôle de l'appareil/Contrôle de l'appareil

1.1 Acquisition du numéro de série de la caméra/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);

résultat:
insérez la description de l'image ici

1.2 Paramètre de nommage personnalisé de la caméra et acquisition/DeviceUserID

	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);

résultat:
insérez la description de l'image ici

1.3 Acquisition du temps de mise sous tension de la caméra/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);

résultat:
insérez la description de l'image ici

2. Contrôle du format de l'appareil photo/ImageFormatControl

2.1 Obtenir la largeur et la hauteur maximales de l'image de la caméra

	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 Définir la zone ROI de l'image de la caméra

Remarque : Lorsque la caméra définit la largeur et la hauteur de l'image, la caméra ne peut pas prendre le flux : elle doit être définie avant le démarrage ou après l'arrêt.

	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 Restaurer la zone ROI de l'image de la caméra et restaurer la valeur maximale

	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 Obtenir le format d'image pris en charge par la caméra

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;
		}
	}
}

résultat:
Appareil photo noir et blanc : ![insérer la description de l'image ici](https://img-blog.csdnimg.cn/81aa4d9a473442bcb28dc8114137f7c9.png) Appareil photo couleur :

2.5 Modifier le format d'image de la caméra

	//设置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 Activer/désactiver l'image de test intégrée de la caméra

2.6.1 Désactiver l'image de test (état par défaut)

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

2.6.2 Ouvrir l'image test

	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;
	}

Effet:
insérez la description de l'image ici

2.7 Activer/désactiver l'image de la caméra miroir X, miroir 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);
	}

Effet:
insérez la description de l'image ici

2.8 Activer/désactiver la fonction de filigrane d'image intégrée à la caméra

Les informations de filigrane d'image de la caméra sont utilisées pour imprimer et enregistrer les informations internes de la caméra. Les informations de filigrane se trouvent dans l'interface de diffusion. Le principe
essentiel pour obtenir le filigrane de la caméra dans la structure de l'image est de remplacer une petite partie de l'effectif informations au début de l'en-tête d'image, occupant environ 40 octets Informations de données réelles pour la transmission d'informations sans entraîner de modifications de la taille des données d'image
insérez la description de l'image ici

paramètre Mots clés valeur du paramètre
horodatage Horodatage 0
gagner Gagner 1
exposition Exposition 2
luminosité moyenne LuminositéInfo 3
balance des blancs Balance des blancs 4
Numéro de cadre Compteur d'images 5
nombre de déclencheurs ExtTriggerCount 6
État du niveau d'entrée et de sortie IO LineInputOutput 7
Zone de retour sur investissement ROIPosition 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);
	}

Effet :
lors du processus de récupération active du flux, les informations de filigrane sont obtenues à partir de la structure de l'image et
insérez la description de l'image ici
la fonction de filigrane est désactivée.

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

3. Contrôle des acquisitions/Contrôle des acquisitions

3.1 Réglage du mode de collecte

paramètre Mots clés valeur du paramètre illustrer
acquisition d'une seule image SingleFrame 0 Il est généralement utilisé pour des logiciels spéciaux tels que visionpro, et il n'est pas recommandé d'utiliser ce mode normalement.
acquisition continue Continu 2 Modes couramment utilisés, acquisition d'une seule image à déclenchement doux, acquisition à déclenchement dur, prise de photos en continu, tous utilisent ce mode 
	nRet = MV_CC_SetEnumValue(handle, "AcquisitionMode", 2);
	if (MV_OK != nRet)
	{
    
    
		printf("Set FrameSpecInfofail! nRet [0x%x]\n", nRet);
	}

3.2 Paramètres d'acquisition multi-images/AcquisitionBurstFrameCount

AcquisitionBurstFrameCount : en mode déclencheur, combien d'images sont acquises une fois déclenchées, la valeur par défaut est 1 ;
si elle est définie sur 2, la caméra reçoit un signal et acquiert automatiquement deux images, et la fréquence d'acquisition change en fonction de la fréquence d'images

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

3.3 Contrôle de la fréquence d'images/AcquisitionFrameRate

	//设置相机帧率，需注意不要超过相机支持的最大的帧率（相机规格书），超过了也没有意义
	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 Réglage du mode de déclenchement

3.4.1 Réglage du déclenchement progressif/Logiciel

	// 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);
	}

Lorsque vous devez prendre une photo, exécutez la commande command, exécutez-la une fois et l'appareil photo prendra une photo (uniquement après l'activation de la commande startgrabing)

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

3.4.2 Réglage/ligne de déclenchement dur

Le déclencheur dur doit être associé au câblage du déclencheur dur, et il existe de nombreux paramètres correspondants . Reportez-vous à : Module de fonction de caméra industrielle Hikvision - Contrôle d'entrée et de sortie IO,
y compris :
1. Mode de déclenchement : TriggerMode est défini sur 1, le mode de déclenchement est allumé
2. Sélection de la source de déclenchement : TriggerSource Réglez-le sur 0, choisissez line0, vous pouvez également choisir line2, ou choisir de toute façon ; line0 et line2 dépendent du câblage du circuit matériel, prennent de toute façon en charge le déclenchement doux et le déclenchement dur en même temps, il dépend si la caméra prend en charge 3. Edge signal TriggerActivation :
déclencheur de front montant par défaut (ne peut pas être défini)
4. Trigger cache TriggerCacheEnable : désactivé par défaut. Lorsque l'appareil photo reçoit deux signaux de déclenchement en même temps, si cette fonction n'est pas activée, l'appareil photo ne répondra qu'à un seul signal et produira une image ; une fois allumé, l'appareil photo mettra automatiquement en cache le deuxième signal et traitera immédiatement après le traitement du signal précédent Signal tampon
5. Délai de déclenchement TriggerDelay : après réception du signal, un délai fixe pendant une période de temps avant l'exposition
6. Réglage du filtre LineDebouncerTime : supprimez les problèmes de signal et la gigue, ajustez en fonction des conditions réelles

	// 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 Réglage de déclenchement arbitraire/Quoi qu'il en soit

Quoi qu'il en soit, la caméra peut répondre aux commandes de déclenchement progressif et peut également répondre aux signaux de déclenchement dur line0, line2
Notez que lorsque vous devez utiliser cette fonction, vous devez savoir si la caméra prend en charge cette fonction

	// 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 Paramètres d'exposition

3.5.1 Réglage manuel de l'exposition

	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 Réglage de l'exposition automatique

	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 Réglage de l'exposition ultra-courte

		//标准曝光模式
		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);
			}
		}

Commutation de gain multi-exposition 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. Contrôle analogique/Contrôle analogique

4.1 Réglage du gain analogique

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

4.2 Réglage du gain numérique

	//打开数字增益使能
	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 Réglage 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 Réglage de la netteté/Netteté

4.4.1 Paramètres de netteté de l'appareil photo

Le traitement interne de la caméra industrielle elle-même prend en charge le réglage de la netteté (traitement ISP du matériel de la caméra).
La netteté doit prêter attention au format d'image de la caméra. Par exemple, YUV, RVB, MONO10, MONO12 et d'autres formats ne prennent pas en charge la netteté, il doit être réalisé par d'autres méthodes

	//打开锐度使能
	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 Réglage de la netteté du SDK

Lorsque le matériel de la caméra ne prend pas en charge le traitement de la netteté dans certains cas, Hikvision SDK fournit un appel d'interface de netteté au niveau du logiciel.
Seuls les formats mono8 et RVB sont pris en charge. Les autres formats d'image doivent d'abord être convertis en ces deux formats.

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 Réglage de la balance des blancs/BalanceWhiteAuto

4.5.1 Balance des blancs automatique

	//开启自动白平衡
	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 des blancs manuelle

	//关闭自动白平衡
	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. Contrôle E/S numérique/DigitalIOControl

Contrôle de sortie 5.1IO

Le contrôle IO de la caméra est principalement utilisé pour contrôler la sortie du signal IO .

5.2 Introduction à la sortie IO et aux événements de sortie

La sortie IO peut également être contrôlée par la caméra. À différentes périodes de temps lorsque la caméra fonctionne, un signal de sortie est donné pour contrôler les appareils externes. Les événements IO pris en charge par les caméras industrielles Hikvision incluent les éléments suivants :

nom de la source d'événement Mots clés valeur du paramètre Description de la fonction
début de l'exposition ExpositionDébutActif 0 Lorsque le capteur commence à s'exposer, le signal de sortie
début de la collecte AcquisitionStartActive 1 Signal de sortie au démarrage de la lecture des données, heure de début de la lecture des trames
fin de collecte AcquisitionArrêtActif 2 Signal de sortie à la fin de la lecture des données, heure de fin de la lecture des trames
Début de parcelle FrameBurstStartActive 3 Le signal est émis lorsque les données d'image commencent à être envoyées via le lien, et le signal n'est émis que lorsque brust> 2, ce qui est souvent inutile
fin du dessin FrameBurstEndActive 4 Lorsque les données d'image sont envoyées via le lien, le signal est émis à la fin du lien et le signal n'est émis que lorsque brust> 2, ce qui est souvent inutile
sortie de déclenchement progressif SoftTriggerActive 5 Le logiciel appelle la commande command time, la sortie, l'utilisateur peut la contrôler indépendamment
sortie de déclenchement dur HardTriggerActive 6 Lorsque le signal d'entrée de la caméra line0 \ 2 reçoit le signal d'entrée, il émet un signal de sortie
sortie compteur MinuterieActive 7 Minuterie, calcule le nombre de signaux spécifiés reçus par line0 et line2, et émet un signal de sortie
déclencher la sortie d'attente FrameTriggerWait 8 L'appareil photo peut être déclenché, et lorsque l'exposition est collectée, le signal de déclenchement

Le démarrage de l'exposition, la sortie de déclenchement progressif et la sortie de déclenchement dur sont couramment utilisés
. Par exemple :

	//参数初始化
	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. Contrôle de commande d'action/ActionControl

7. Contrôle d'accès aux fichiers/FileAccessControl

8. Surveillance des événements/Contrôle des événements

8.1 Heure de fin d'exposition

9. Contrôle de bloc de données/ChunkDataControl

10. Contrôle de la couche transport / TransportLayerControl

10.1 Réglage du temps de pulsation

//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. Contrôle de jeu d'utilisateur/UserSetControl

11.1 Enregistrer les paramètres dans la caméra

Enregistrez les paramètres dans userset pour vous assurer que les paramètres ne disparaîtront pas après la mise hors tension de la caméra

//初始化部分，放在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 Restaurer les paramètres d'usine par défaut

//相机停止采集后才能调用
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);
}

Je suppose que tu aimes

Origine blog.csdn.net/qq_23107577/article/details/121077409
conseillé
Classement
du quotidien
Plus
2024-07-17(0)
2024-07-16(0)
2024-07-15(0)
2024-07-14(0)
2024-07-13(0)
2024-07-12(0)
2024-07-11(0)
2024-07-10(0)
2024-07-09(0)
2024-07-08(0)

Code World

© 2018 codetd.com