HALCON Website / HALCON Operator-Referenz / Segmentation / Klassifikation
KlassenKlassen | | Operatoren

class_ndim_normclass_ndim_normClassNdimNormClassNdimNormclass_ndim_norm (Operator)

Name

class_ndim_normclass_ndim_normClassNdimNormClassNdimNormclass_ndim_norm — Ausführen einer Pixelklassifikation mit Hyperkugeln oder Hyperwürfeln.

Signatur

class_ndim_norm(MultiChannelImage : Regions : Metric, SingleMultiple, Radius, Center : )

Herror class_ndim_norm(const Hobject MultiChannelImage, Hobject* Regions, const char* Metric, const char* SingleMultiple, double Radius, double Center)

Herror T_class_ndim_norm(const Hobject MultiChannelImage, Hobject* Regions, const Htuple Metric, const Htuple SingleMultiple, const Htuple Radius, const Htuple Center)

void ClassNdimNorm(const HObject& MultiChannelImage, HObject* Regions, const HTuple& Metric, const HTuple& SingleMultiple, const HTuple& Radius, const HTuple& Center)

HRegion HImage::ClassNdimNorm(const HString& Metric, const HString& SingleMultiple, const HTuple& Radius, const HTuple& Center) const

HRegion HImage::ClassNdimNorm(const HString& Metric, const HString& SingleMultiple, double Radius, double Center) const

HRegion HImage::ClassNdimNorm(const char* Metric, const char* SingleMultiple, double Radius, double Center) const

HRegion HImage::ClassNdimNorm(const wchar_t* Metric, const wchar_t* SingleMultiple, double Radius, double Center) const   (Nur Windows)

static void HOperatorSet.ClassNdimNorm(HObject multiChannelImage, out HObject regions, HTuple metric, HTuple singleMultiple, HTuple radius, HTuple center)

HRegion HImage.ClassNdimNorm(string metric, string singleMultiple, HTuple radius, HTuple center)

HRegion HImage.ClassNdimNorm(string metric, string singleMultiple, double radius, double center)

def class_ndim_norm(multi_channel_image: HObject, metric: str, single_multiple: str, radius: MaybeSequence[Union[int, float]], center: MaybeSequence[Union[int, float]]) -> HObject

Beschreibung

class_ndim_normclass_ndim_normClassNdimNormClassNdimNormClassNdimNormclass_ndim_norm klassifiziert die Pixel der in MultiChannelImageMultiChannelImageMultiChannelImageMultiChannelImagemultiChannelImagemulti_channel_image enthaltenen Bilder. Als Ergebnis werden in RegionsRegionsRegionsRegionsregionsregions für jedes Klassifizierungsobjekt eine (oder mehrere) Region(en) ausgegeben (s.u.). Die verwendete Metrik ('euclid'"euclid""euclid""euclid""euclid""euclid" oder 'maximum'"maximum""maximum""maximum""maximum""maximum") wird mit MetricMetricMetricMetricmetricmetric festgelegt. Es ist darauf zu achten, dass dieser Parameter genauso wie bei learn_ndim_normlearn_ndim_normLearnNdimNormLearnNdimNormLearnNdimNormlearn_ndim_norm besetzt wird. Mit SingleMultipleSingleMultipleSingleMultipleSingleMultiplesingleMultiplesingle_multiple wird festgelegt, ob als Ergebnis (in RegionsRegionsRegionsRegionsregionsregions) eine Region ('single'"single""single""single""single""single") oder für jedes Cluster eine eigene Region ('multiple'"multiple""multiple""multiple""multiple""multiple") erzeugt werden soll. Der Parameter RadiusRadiusRadiusRadiusradiusradius gibt die Clusterradien bzw. die halbe Clusterkantenlänge an. CenterCenterCenterCentercentercenter enthält die Koordinaten aller Clusterzentren.

Ausführungsinformationen

Parameter

MultiChannelImageMultiChannelImageMultiChannelImageMultiChannelImagemultiChannelImagemulti_channel_image (input_object)  (multichannel-)image(-array) → objectHImageHObjectHImageHobject (byte)

Mehrkanaliges Eingabebild.

RegionsRegionsRegionsRegionsregionsregions (output_object)  region-array → objectHRegionHObjectHRegionHobject *

Ergebnis der Klassifikation.

MetricMetricMetricMetricmetricmetric (input_control)  string → HTuplestrHTupleHtuple (string) (string) (HString) (char*)

Verwendete Metrik.

Defaultwert: 'euclid' "euclid" "euclid" "euclid" "euclid" "euclid"

Werteliste: 'euclid'"euclid""euclid""euclid""euclid""euclid", 'maximum'"maximum""maximum""maximum""maximum""maximum"

SingleMultipleSingleMultipleSingleMultipleSingleMultiplesingleMultiplesingle_multiple (input_control)  string → HTuplestrHTupleHtuple (string) (string) (HString) (char*)

Als Ergebnis eine Region oder für jeden Cluster eine eigene Region.

Defaultwert: 'single' "single" "single" "single" "single" "single"

Werteliste: 'multiple'"multiple""multiple""multiple""multiple""multiple", 'single'"single""single""single""single""single"

RadiusRadiusRadiusRadiusradiusradius (input_control)  number(-array) → HTupleMaybeSequence[Union[int, float]]HTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Clusterradien bzw. halbe Clusterkantenlängen (von learn_ndim_normlearn_ndim_normLearnNdimNormLearnNdimNormLearnNdimNormlearn_ndim_norm geliefert).

CenterCenterCenterCentercentercenter (input_control)  number(-array) → HTupleMaybeSequence[Union[int, float]]HTupleHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)

Koordinaten aller Clusterzentren (von learn_ndim_normlearn_ndim_normLearnNdimNormLearnNdimNormLearnNdimNormlearn_ndim_norm geliefert).

Beispiel (C++)

#include "HIOStream.h"
#if !defined(USE_IOSTREAM_H)
using namespace std;
#endif
#include "HalconCpp.h"
using namespace Halcon;

int main ()
{
  HImage   image ("meer"),
           t1, t2, t3,
           m1, m2, m3, m;

  HWindow  w;

  w.SetColor ("green");
  image.Display (w);

  cout << "Draw your region of interest " << endl;

  HRegion testreg = w.DrawRegion ();

  t1 = image.TextureLaws ("el", 2, 5);     m1 = t1.MeanImage (21, 21);
  t2 = image.TextureLaws ("es", 2, 5);     m2 = t2.MeanImage (21, 21);
  t3 = image.TextureLaws ("le", 2, 5);     m3 = t3.MeanImage (21, 21);

  m  = m1.Compose3 (m2, m3);

  Tuple Metric = "euclid";
  Tuple Radius = 20.0;
  Tuple MinNum = 5;
  Tuple NbrCha = 3;

  HRegion empty;
  Tuple cen, t;

  Radius = testreg.LearnNdimNorm (empty, m, Metric, Radius,
                                  MinNum, NbrCha, &cen, &t);
  Tuple RegMod = "multiple";

  HRegionArray reg = m.ClassNdimNorm (Metric, RegMod, Radius, cen, NbrCha);

  w.SetColored (12);
  reg.Display (w);
  cout << "Result of classification" << endl;
  return (0);
}

Beispiel (C)

read_image(&Image,"meer:);
open_window(0,0,-1,-1,0,"visible","",&WindowHandle);
disp_image(Image,WindowHandle);
fwrite_string("draw region of interest with the mouse");
fnew_line();
set_color(WindowHandle,"green");
draw_region(&Testreg,draw_region);
/* Texture transformation for 3-dimensional charachteristic */
texture_laws(Image,&T1,"el",2,5);
mean_image(T1,&M1,21,21);
texture_laws(Image,&T2,"es",2,5);
mean_image(T2,&M2,21,21);
texture_laws(Image,&T3,"le",2,5);
mean_image(T3,&M3,21,21);
compose3(M1,M2,M3,&M);
/* Cluster for 3-dimensional characteristic area determine training area */
create_tuple(&Metric,1);
set_s(Metric,"euclid",0);
create_tuple(&Radius,1);
set_d(Radius,20.0,0);
create_tuple(&MinNumber,1);
set_i(MinNumber,5,0);
T_learn_ndim_norm(Testobj,EMPTY_REGION,&M,"euclid",Radius,MinNumber,
                  &Radius,&Center,NULL);
/* Segmentation */
create_tuple(&RegionMode,1);
set_s(RegionMode,"multiple",0);
class_ndim_norm(M,&Regions,Metric,RegionMode,Radius,Center);
set_colored(WindowHandle,12);
disp_region(Regions,WindowHandle);
fwrite_string("Result of classification;");
fwrite_string("Each cluster in another color.");
fnew_line();

Beispiel (C++)

#include "HIOStream.h"
#if !defined(USE_IOSTREAM_H)
using namespace std;
#endif
#include "HalconCpp.h"
using namespace Halcon;

int main ()
{
  HImage   image ("meer"),
           t1, t2, t3,
           m1, m2, m3, m;

  HWindow  w;

  w.SetColor ("green");
  image.Display (w);

  cout << "Draw your region of interest " << endl;

  HRegion testreg = w.DrawRegion ();

  t1 = image.TextureLaws ("el", 2, 5);     m1 = t1.MeanImage (21, 21);
  t2 = image.TextureLaws ("es", 2, 5);     m2 = t2.MeanImage (21, 21);
  t3 = image.TextureLaws ("le", 2, 5);     m3 = t3.MeanImage (21, 21);

  m  = m1.Compose3 (m2, m3);

  Tuple Metric = "euclid";
  Tuple Radius = 20.0;
  Tuple MinNum = 5;
  Tuple NbrCha = 3;

  HRegion empty;
  Tuple cen, t;

  Radius = testreg.LearnNdimNorm (empty, m, Metric, Radius,
                                  MinNum, NbrCha, &cen, &t);
  Tuple RegMod = "multiple";

  HRegionArray reg = m.ClassNdimNorm (Metric, RegMod, Radius, cen, NbrCha);

  w.SetColored (12);
  reg.Display (w);
  cout << "Result of classification" << endl;
  return (0);
}

Beispiel (C++)

#include "HIOStream.h"
#if !defined(USE_IOSTREAM_H)
using namespace std;
#endif
#include "HalconCpp.h"
using namespace Halcon;

int main ()
{
  HImage   image ("meer"),
           t1, t2, t3,
           m1, m2, m3, m;

  HWindow  w;

  w.SetColor ("green");
  image.Display (w);

  cout << "Draw your region of interest " << endl;

  HRegion testreg = w.DrawRegion ();

  t1 = image.TextureLaws ("el", 2, 5);     m1 = t1.MeanImage (21, 21);
  t2 = image.TextureLaws ("es", 2, 5);     m2 = t2.MeanImage (21, 21);
  t3 = image.TextureLaws ("le", 2, 5);     m3 = t3.MeanImage (21, 21);

  m  = m1.Compose3 (m2, m3);

  Tuple Metric = "euclid";
  Tuple Radius = 20.0;
  Tuple MinNum = 5;
  Tuple NbrCha = 3;

  HRegion empty;
  Tuple cen, t;

  Radius = testreg.LearnNdimNorm (empty, m, Metric, Radius,
                                  MinNum, NbrCha, &cen, &t);
  Tuple RegMod = "multiple";

  HRegionArray reg = m.ClassNdimNorm (Metric, RegMod, Radius, cen, NbrCha);

  w.SetColored (12);
  reg.Display (w);
  cout << "Result of classification" << endl;
  return (0);
}

Beispiel (C++)

#include "HIOStream.h"
#if !defined(USE_IOSTREAM_H)
using namespace std;
#endif
#include "HalconCpp.h"
using namespace Halcon;

int main ()
{
  HImage   image ("meer"),
           t1, t2, t3,
           m1, m2, m3, m;

  HWindow  w;

  w.SetColor ("green");
  image.Display (w);

  cout << "Draw your region of interest " << endl;

  HRegion testreg = w.DrawRegion ();

  t1 = image.TextureLaws ("el", 2, 5);     m1 = t1.MeanImage (21, 21);
  t2 = image.TextureLaws ("es", 2, 5);     m2 = t2.MeanImage (21, 21);
  t3 = image.TextureLaws ("le", 2, 5);     m3 = t3.MeanImage (21, 21);

  m  = m1.Compose3 (m2, m3);

  Tuple Metric = "euclid";
  Tuple Radius = 20.0;
  Tuple MinNum = 5;
  Tuple NbrCha = 3;

  HRegion empty;
  Tuple cen, t;

  Radius = testreg.LearnNdimNorm (empty, m, Metric, Radius,
                                  MinNum, NbrCha, &cen, &t);
  Tuple RegMod = "multiple";

  HRegionArray reg = m.ClassNdimNorm (Metric, RegMod, Radius, cen, NbrCha);

  w.SetColored (12);
  reg.Display (w);
  cout << "Result of classification" << endl;
  return (0);
}

Komplexität

Sei N die Anzahl der Cluster (= Länge der Tupel Radius und Center) und A die Fläche der Eingaberegion(en), dann ist die Laufzeitkomplexität O(N,A).

Ergebnis

class_ndim_normclass_ndim_normClassNdimNormClassNdimNormClassNdimNormclass_ndim_norm liefert den Wert 2 (H_MSG_TRUE), falls die Parameter korrekt sind. Für das Verhalten bzgl. der Eingabebilder und Ausgaberegionen sind die Flags 'no_object_result'"no_object_result""no_object_result""no_object_result""no_object_result""no_object_result", 'empty_region_result'"empty_region_result""empty_region_result""empty_region_result""empty_region_result""empty_region_result" und 'store_empty_region'"store_empty_region""store_empty_region""store_empty_region""store_empty_region""store_empty_region" einstellbar (siehe set_systemset_systemSetSystemSetSystemSetSystemset_system). Gegebenenfalls wird eine Fehlerbehandlung durchgeführt.

Vorgänger

learn_ndim_normlearn_ndim_normLearnNdimNormLearnNdimNormLearnNdimNormlearn_ndim_norm, compose2compose2Compose2Compose2Compose2compose2, compose3compose3Compose3Compose3Compose3compose3, compose4compose4Compose4Compose4Compose4compose4, compose5compose5Compose5Compose5Compose5compose5, compose6compose6Compose6Compose6Compose6compose6, compose7compose7Compose7Compose7Compose7compose7

Nachfolger

connectionconnectionConnectionConnectionConnectionconnection, select_shapeselect_shapeSelectShapeSelectShapeSelectShapeselect_shape, reduce_domainreduce_domainReduceDomainReduceDomainReduceDomainreduce_domain, select_grayselect_graySelectGraySelectGraySelectGrayselect_gray

Alternativen

class_2dim_supclass_2dim_supClass2dimSupClass2dimSupClass2dimSupclass_2dim_sup, class_2dim_unsupclass_2dim_unsupClass2dimUnsupClass2dimUnsupClass2dimUnsupclass_2dim_unsup

Modul

Foundation

KlassenKlassen | | Operatoren
HALCON Operator-Referenz 22.11.4.0 Copyright © 1996-2025 MVTec Software GmbH
Follow us on