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

class_ndim_normclass_ndim_normClassNdimNormclass_ndim_normClassNdimNormClassNdimNorm (Operator)

Name

class_ndim_normclass_ndim_normClassNdimNormclass_ndim_normClassNdimNormClassNdimNorm — 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)

Herror class_ndim_norm(Hobject MultiChannelImage, Hobject* Regions, const HTuple& Metric, const HTuple& SingleMultiple, const HTuple& Radius, const HTuple& Center)

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

HRegionArray HImageArray::ClassNdimNorm(const HTuple& Metric, const HTuple& SingleMultiple, const HTuple& Radius, const HTuple& Center) const

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

void HOperatorSetX.ClassNdimNorm(
[in] IHUntypedObjectX* MultiChannelImage, [out] IHUntypedObjectX** Regions, [in] VARIANT Metric, [in] VARIANT SingleMultiple, [in] VARIANT Radius, [in] VARIANT Center)

IHRegionX* HImageX.ClassNdimNorm(
[in] BSTR Metric, [in] BSTR SingleMultiple, [in] VARIANT Radius, [in] VARIANT Center)

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)

Beschreibung

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

Parallelisierung

Parameter

MultiChannelImageMultiChannelImageMultiChannelImageMultiChannelImageMultiChannelImagemultiChannelImage (input_object)  (multichannel-)image(-array) → objectHImageHImageHImageHImageXHobject (byte)

Mehrkanaliges Eingabebild.

RegionsRegionsRegionsRegionsRegionsregions (output_object)  region-array → objectHRegionHRegionHRegionArrayHRegionXHobject *

Ergebnis der Klassifikation.

MetricMetricMetricMetricMetricmetric (input_control)  string → HTupleHTupleHTupleVARIANTHtuple (string) (string) (HString) (char*) (BSTR) (char*)

Verwendete Metrik.

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

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

SingleMultipleSingleMultipleSingleMultipleSingleMultipleSingleMultiplesingleMultiple (input_control)  string → HTupleHTupleHTupleVARIANTHtuple (string) (string) (HString) (char*) (BSTR) (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) → HTupleHTupleHTupleVARIANTHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong) (double / Hlong) (double / Hlong)

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

CenterCenterCenterCenterCentercenter (input_control)  number(-array) → HTupleHTupleHTupleVARIANTHtuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong) (double / Hlong) (double / Hlong)

Koordinaten aller Clusterzentren (von learn_ndim_normlearn_ndim_normLearnNdimNormlearn_ndim_normLearnNdimNormLearnNdimNorm geliefert).

Beispiel (C++ (HALCON 5.0-10.0))

#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++ (HALCON 5.0-10.0))

#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++ (HALCON 5.0-10.0))

#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++ (HALCON 5.0-10.0))

#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++ (HALCON 5.0-10.0))

#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_normClassNdimNormclass_ndim_normClassNdimNormClassNdimNorm 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_systemSetSystemset_systemSetSystemSetSystem). Gegebenenfalls wird eine Fehlerbehandlung durchgeführt.

Vorgänger

learn_ndim_normlearn_ndim_normLearnNdimNormlearn_ndim_normLearnNdimNormLearnNdimNorm, compose2compose2Compose2compose2Compose2Compose2, compose3compose3Compose3compose3Compose3Compose3, compose4compose4Compose4compose4Compose4Compose4, compose5compose5Compose5compose5Compose5Compose5, compose6compose6Compose6compose6Compose6Compose6, compose7compose7Compose7compose7Compose7Compose7

Nachfolger

connectionconnectionConnectionconnectionConnectionConnection, select_shapeselect_shapeSelectShapeselect_shapeSelectShapeSelectShape, reduce_domainreduce_domainReduceDomainreduce_domainReduceDomainReduceDomain, select_grayselect_graySelectGrayselect_graySelectGraySelectGray

Alternativen

class_2dim_supclass_2dim_supClass2dimSupclass_2dim_supClass2dimSupClass2dimSup, class_2dim_unsupclass_2dim_unsupClass2dimUnsupclass_2dim_unsupClass2dimUnsupClass2dimUnsup

Modul

Foundation

KlassenKlassenKlassenKlassen | | | | Operatoren
HALCON Operator-Referenz 13.0.4 Copyright © 1996-2019 MVTec Software GmbH