AutoMaskingGraphCutOptions

Inheritance: java.lang.Object, com.aspose.imaging.masking.options.MaskingOptions, com.aspose.imaging.masking.options.GraphCutMaskingOptions

public class AutoMaskingGraphCutOptions extends GraphCutMaskingOptions

GraphCut‑auto‑maskeringsalternativen.

Konstruktörer

Konstruktor	Beskrivning
AutoMaskingGraphCutOptions()	Initierar en ny instans av klassen AutoMaskingGraphCutOptions.

Metoder

Metod	Beskrivning
getDefaultForegroundStrokes()	Hämtar de förberäknade standardförgrundsstrecken.
getDefaultBackgroundStrokes()	Hämtar standardbakgrundsstrecken.
getDefaultObjectsRectangles()	Hämtar standardobjektens rektanglar.
getAssumedObjects()	Hämtar de antagna objekten.
setAssumedObjects(List value)	Ställer in de antagna objekten.
getCalculateDefaultStrokes()	Hämtar ett värde som indikerar om standardstrecken ska beräknas.
setCalculateDefaultStrokes(boolean value)	Ställer in ett värde som indikerar om standardstrecken ska beräknas.
getPrecalculationProgressEventHandler()	Hämtar standardpunkternas förberäkningsprocessens framstegshändelsehanterare.
setPrecalculationProgressEventHandler(ProgressEventHandler value)	Ställer in standardpunkternas förberäkningsprocessens framstegshändelsehanterare.

Example: Saving image masking result with feathering based on image size.

Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek. Bildmaskering utförs med automatiskt beräknade standardstreck. Egenskapen Args i AutoMaskingGraphCutOptions kan utelämnas eftersom standardstrecken placeras där i slutet. MaskingResult[] results;

MaskingResult[] results; 
            
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius((Math.max(image.getWidth(), image.getHeight()) / 500) + 1);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}
            

Example: Saving image masking result with feathering based on image size.

Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek. Bildmaskering utförs med automatiskt beräknade standardstreck. Dessutom specificeras data för de två antagna objekten i egenskapen AssumedObjects i AutoMaskingGraphCutOptions.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius((Math.max(image.getWidth(), image.getHeight()) / 500) + 1);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}
            

Example: Saving image masking result with feathering based on image size and re-using masking options for the new masking iteration.

Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek och återanvänder maskeringsalternativ för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstreck. Dessutom specificeras data för de två antagna objekten i egenskapen AssumedObjects i AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds-/förgrundsstrecken och en ny maskeringsiteration utförs.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.
Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    // Genom att återanvända AutoMaskingGraphCutOptions behövs inte standardstrecksberäkningarna utföras en andra gång.
    options.setCalculateDefaultStrokes(false);
    // När både standardstreck och ObjectsPoints i Args-egenskapen i AutoMaskingArgs tillhandahålls, kombineras punktarrayerna i slutändan.
    // Det första ObjectsPoints-arrayet betraktas som ett bakgrundspunktsarray och
    // det andra ObjectsPoints‑arrayet anses vara ett förgrundspunkts‑array.
    // När både DefaultObjectsRectangles och ObjectsRectangles i Args‑egenskapen för AutoMaskingArgs tillhandahålls,
    // används endast arrayen från Args.
    AutoMaskingArgs args = new AutoMaskingArgs();
    args.setObjectsPoints(new Point[][]
            {
                    new Point[] { new Point(100, 100), new Point(150, 100) },
                    new Point[] { new Point(500, 200) },
            });

    args.setObjectsRectangles( new Rectangle[] { new Rectangle(100, 100, 300, 300) });
    options.setArgs(args);
    results = new ImageMasking(image).decompose(options);
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

Example: Saving image masking result with feathering based on image size, modifying obtained default strokes and using it for the new masking iteration.

Sparar bildmaskeringsresultatet med fjädring baserat på bildstorlek, modifierar de erhållna standardstrokarna och använder dem för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstrokar. Dessutom anges data för de två antagna objekten i AssumedObjects‑egenskapen för AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds‑/förgrundsstrokarna och en ytterligare maskeringsiteration utförs med en ny GraphCutMaskingOptions‑instans.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.

Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

appliedBackgroundStrokes[5] = new Point(100, 100);
appliedBackgroundStrokes[15] = new Point(150, 100);

appliedForegroundStrokes[1] = new Point(500, 200);

appliedObjectRectangles[0] = new Rectangle(100, 100, 300, 300);

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingArgs args = new AutoMaskingArgs();
        args.setObjectsPoints(new Point[][]
                {
                        appliedBackgroundStrokes,
                        appliedForegroundStrokes
                });

        args.setObjectsRectangles(appliedObjectRectangles);
                    
        GraphCutMaskingOptions graphCutOptions = new GraphCutMaskingOptions();
        graphCutOptions.setFeatheringRadius(3);
        graphCutOptions.setMethod(SegmentationMethod.GraphCut);
        graphCutOptions.setDecompose(false);
        graphCutOptions.setExportOptions(pngOptions);
        graphCutOptions.setBackgroundReplacementColor(Color.getTransparent());
        graphCutOptions.setArgs(args);
                    
        results = new ImageMasking(image).decompose(graphCutOptions);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

AutoMaskingGraphCutOptions()

public AutoMaskingGraphCutOptions()

Initierar en ny instans av klassen AutoMaskingGraphCutOptions.

getDefaultForegroundStrokes()

public final Point[] getDefaultForegroundStrokes()

Hämtar de förberäknade standardförgrundsstrecken.

Returns: com.aspose.imaging.Point[] – de förberäknade standardförgrundsstrokarna.

Example: Saving image masking result with feathering based on image size and re-using masking options for the new masking iteration. Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek och återanvänder maskeringsalternativ för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstreck. Dessutom specificeras data för de två antagna objekten i egenskapen AssumedObjects i AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds-/förgrundsstrecken och en ny maskeringsiteration utförs.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.
Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    // Genom att återanvända AutoMaskingGraphCutOptions behövs inte standardstrecksberäkningarna utföras en andra gång.
    options.setCalculateDefaultStrokes(false);
    // När både standardstreck och ObjectsPoints i Args-egenskapen i AutoMaskingArgs tillhandahålls, kombineras punktarrayerna i slutändan.
    // Det första ObjectsPoints-arrayet betraktas som ett bakgrundspunktsarray och
    // det andra ObjectsPoints‑arrayet anses vara ett förgrundspunkts‑array.
    // När både DefaultObjectsRectangles och ObjectsRectangles i Args‑egenskapen för AutoMaskingArgs tillhandahålls,
    // används endast arrayen från Args.
    AutoMaskingArgs args = new AutoMaskingArgs();
    args.setObjectsPoints(new Point[][]
            {
                    new Point[] { new Point(100, 100), new Point(150, 100) },
                    new Point[] { new Point(500, 200) },
            });

    args.setObjectsRectangles( new Rectangle[] { new Rectangle(100, 100, 300, 300) });
    options.setArgs(args);
    results = new ImageMasking(image).decompose(options);
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

Example: Saving image masking result with feathering based on image size, modifying obtained default strokes and using it for the new masking iteration. Sparar bildmaskeringsresultatet med fjädring baserat på bildstorlek, modifierar de erhållna standardstrokarna och använder dem för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstrokar. Dessutom anges data för de två antagna objekten i AssumedObjects‑egenskapen för AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds‑/förgrundsstrokarna och en ytterligare maskeringsiteration utförs med en ny GraphCutMaskingOptions‑instans.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.

Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

appliedBackgroundStrokes[5] = new Point(100, 100);
appliedBackgroundStrokes[15] = new Point(150, 100);

appliedForegroundStrokes[1] = new Point(500, 200);

appliedObjectRectangles[0] = new Rectangle(100, 100, 300, 300);

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingArgs args = new AutoMaskingArgs();
        args.setObjectsPoints(new Point[][]
                {
                        appliedBackgroundStrokes,
                        appliedForegroundStrokes
                });

        args.setObjectsRectangles(appliedObjectRectangles);
                    
        GraphCutMaskingOptions graphCutOptions = new GraphCutMaskingOptions();
        graphCutOptions.setFeatheringRadius(3);
        graphCutOptions.setMethod(SegmentationMethod.GraphCut);
        graphCutOptions.setDecompose(false);
        graphCutOptions.setExportOptions(pngOptions);
        graphCutOptions.setBackgroundReplacementColor(Color.getTransparent());
        graphCutOptions.setArgs(args);
                    
        results = new ImageMasking(image).decompose(graphCutOptions);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

getDefaultBackgroundStrokes()

public final Point[] getDefaultBackgroundStrokes()

Hämtar standardbakgrundsstrecken.

Returns: com.aspose.imaging.Point[] – standardbakgrundsstrokarna.

Example: Saving image masking result with feathering based on image size and re-using masking options for the new masking iteration. Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek och återanvänder maskeringsalternativ för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstreck. Dessutom specificeras data för de två antagna objekten i egenskapen AssumedObjects i AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds-/förgrundsstrecken och en ny maskeringsiteration utförs.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.
Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    // Genom att återanvända AutoMaskingGraphCutOptions behövs inte standardstrecksberäkningarna utföras en andra gång.
    options.setCalculateDefaultStrokes(false);
    // När både standardstreck och ObjectsPoints i Args-egenskapen i AutoMaskingArgs tillhandahålls, kombineras punktarrayerna i slutändan.
    // Det första ObjectsPoints-arrayet betraktas som ett bakgrundspunktsarray och
    // det andra ObjectsPoints‑arrayet anses vara ett förgrundspunkts‑array.
    // När både DefaultObjectsRectangles och ObjectsRectangles i Args‑egenskapen för AutoMaskingArgs tillhandahålls,
    // används endast arrayen från Args.
    AutoMaskingArgs args = new AutoMaskingArgs();
    args.setObjectsPoints(new Point[][]
            {
                    new Point[] { new Point(100, 100), new Point(150, 100) },
                    new Point[] { new Point(500, 200) },
            });

    args.setObjectsRectangles( new Rectangle[] { new Rectangle(100, 100, 300, 300) });
    options.setArgs(args);
    results = new ImageMasking(image).decompose(options);
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

Example: Saving image masking result with feathering based on image size, modifying obtained default strokes and using it for the new masking iteration. Sparar bildmaskeringsresultatet med fjädring baserat på bildstorlek, modifierar de erhållna standardstrokarna och använder dem för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstrokar. Dessutom anges data för de två antagna objekten i AssumedObjects‑egenskapen för AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds‑/förgrundsstrokarna och en ytterligare maskeringsiteration utförs med en ny GraphCutMaskingOptions‑instans.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.

Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

appliedBackgroundStrokes[5] = new Point(100, 100);
appliedBackgroundStrokes[15] = new Point(150, 100);

appliedForegroundStrokes[1] = new Point(500, 200);

appliedObjectRectangles[0] = new Rectangle(100, 100, 300, 300);

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingArgs args = new AutoMaskingArgs();
        args.setObjectsPoints(new Point[][]
                {
                        appliedBackgroundStrokes,
                        appliedForegroundStrokes
                });

        args.setObjectsRectangles(appliedObjectRectangles);
                    
        GraphCutMaskingOptions graphCutOptions = new GraphCutMaskingOptions();
        graphCutOptions.setFeatheringRadius(3);
        graphCutOptions.setMethod(SegmentationMethod.GraphCut);
        graphCutOptions.setDecompose(false);
        graphCutOptions.setExportOptions(pngOptions);
        graphCutOptions.setBackgroundReplacementColor(Color.getTransparent());
        graphCutOptions.setArgs(args);
                    
        results = new ImageMasking(image).decompose(graphCutOptions);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

getDefaultObjectsRectangles()

public final Rectangle[] getDefaultObjectsRectangles()

Hämtar standardobjektens rektanglar.

Returns: com.aspose.imaging.Rectangle[] – standardobjektens rektanglar.

Example: Saving image masking result with feathering based on image size and re-using masking options for the new masking iteration. Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek och återanvänder maskeringsalternativ för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstreck. Dessutom specificeras data för de två antagna objekten i egenskapen AssumedObjects i AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds-/förgrundsstrecken och en ny maskeringsiteration utförs.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.
Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    // Genom att återanvända AutoMaskingGraphCutOptions behövs inte standardstrecksberäkningarna utföras en andra gång.
    options.setCalculateDefaultStrokes(false);
    // När både standardstreck och ObjectsPoints i Args-egenskapen i AutoMaskingArgs tillhandahålls, kombineras punktarrayerna i slutändan.
    // Det första ObjectsPoints-arrayet betraktas som ett bakgrundspunktsarray och
    // det andra ObjectsPoints‑arrayet anses vara ett förgrundspunkts‑array.
    // När både DefaultObjectsRectangles och ObjectsRectangles i Args‑egenskapen för AutoMaskingArgs tillhandahålls,
    // används endast arrayen från Args.
    AutoMaskingArgs args = new AutoMaskingArgs();
    args.setObjectsPoints(new Point[][]
            {
                    new Point[] { new Point(100, 100), new Point(150, 100) },
                    new Point[] { new Point(500, 200) },
            });

    args.setObjectsRectangles( new Rectangle[] { new Rectangle(100, 100, 300, 300) });
    options.setArgs(args);
    results = new ImageMasking(image).decompose(options);
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

Example: Saving image masking result with feathering based on image size, modifying obtained default strokes and using it for the new masking iteration. Sparar bildmaskeringsresultatet med fjädring baserat på bildstorlek, modifierar de erhållna standardstrokarna och använder dem för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstrokar. Dessutom anges data för de två antagna objekten i AssumedObjects‑egenskapen för AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds‑/förgrundsstrokarna och en ytterligare maskeringsiteration utförs med en ny GraphCutMaskingOptions‑instans.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.

Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

appliedBackgroundStrokes[5] = new Point(100, 100);
appliedBackgroundStrokes[15] = new Point(150, 100);

appliedForegroundStrokes[1] = new Point(500, 200);

appliedObjectRectangles[0] = new Rectangle(100, 100, 300, 300);

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingArgs args = new AutoMaskingArgs();
        args.setObjectsPoints(new Point[][]
                {
                        appliedBackgroundStrokes,
                        appliedForegroundStrokes
                });

        args.setObjectsRectangles(appliedObjectRectangles);
                    
        GraphCutMaskingOptions graphCutOptions = new GraphCutMaskingOptions();
        graphCutOptions.setFeatheringRadius(3);
        graphCutOptions.setMethod(SegmentationMethod.GraphCut);
        graphCutOptions.setDecompose(false);
        graphCutOptions.setExportOptions(pngOptions);
        graphCutOptions.setBackgroundReplacementColor(Color.getTransparent());
        graphCutOptions.setArgs(args);
                    
        results = new ImageMasking(image).decompose(graphCutOptions);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

getAssumedObjects()

public final List<AssumedObjectData> getAssumedObjects()

Hämtar de antagna objekten.

Returns: java.util.List<com.aspose.imaging.masking.options.AssumedObjectData> – de antagna objekten.

setAssumedObjects(List value)

public final void setAssumedObjects(List<AssumedObjectData> value)

Ställer in de antagna objekten.

Parameters:

Parameter	Typ	Beskrivning
värde	java.util.List<com.aspose.imaging.masking.options.AssumedObjectData>	de antagna objekten.

getCalculateDefaultStrokes()

public final boolean getCalculateDefaultStrokes()

Hämtar ett värde som indikerar om standardstrecken ska beräknas.

Returns: boolean – ett värde som indikerar om standardstrokarna ska beräknas.

setCalculateDefaultStrokes(boolean value)

public final void setCalculateDefaultStrokes(boolean value)

Ställer in ett värde som indikerar om standardstrecken ska beräknas.

Parameters:

Parameter	Typ	Beskrivning
värde	boolean	ett värde som indikerar om standardstrokarna ska beräknas.

Example: Saving image masking result with feathering based on image size. Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek. Bildmaskering utförs med automatiskt beräknade standardstreck. Egenskapen Args i AutoMaskingGraphCutOptions kan utelämnas eftersom standardstrecken placeras där i slutet. MaskingResult[] results;

MaskingResult[] results; 
            
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius((Math.max(image.getWidth(), image.getHeight()) / 500) + 1);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}
            

Example: Saving image masking result with feathering based on image size. Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek. Bildmaskering utförs med automatiskt beräknade standardstreck. Dessutom specificeras data för de två antagna objekten i egenskapen AssumedObjects i AutoMaskingGraphCutOptions.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius((Math.max(image.getWidth(), image.getHeight()) / 500) + 1);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}
            

Example: Saving image masking result with feathering based on image size and re-using masking options for the new masking iteration. Sparar resultatet av bildmaskering med mjukning baserat på bildstorlek och återanvänder maskeringsalternativ för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstreck. Dessutom specificeras data för de två antagna objekten i egenskapen AssumedObjects i AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds-/förgrundsstrecken och en ny maskeringsiteration utförs.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.
Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    // Genom att återanvända AutoMaskingGraphCutOptions behövs inte standardstrecksberäkningarna utföras en andra gång.
    options.setCalculateDefaultStrokes(false);
    // När både standardstreck och ObjectsPoints i Args-egenskapen i AutoMaskingArgs tillhandahålls, kombineras punktarrayerna i slutändan.
    // Det första ObjectsPoints-arrayet betraktas som ett bakgrundspunktsarray och
    // det andra ObjectsPoints‑arrayet anses vara ett förgrundspunkts‑array.
    // När både DefaultObjectsRectangles och ObjectsRectangles i Args‑egenskapen för AutoMaskingArgs tillhandahålls,
    // används endast arrayen från Args.
    AutoMaskingArgs args = new AutoMaskingArgs();
    args.setObjectsPoints(new Point[][]
            {
                    new Point[] { new Point(100, 100), new Point(150, 100) },
                    new Point[] { new Point(500, 200) },
            });

    args.setObjectsRectangles( new Rectangle[] { new Rectangle(100, 100, 300, 300) });
    options.setArgs(args);
    results = new ImageMasking(image).decompose(options);
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

Example: Saving image masking result with feathering based on image size, modifying obtained default strokes and using it for the new masking iteration. Sparar bildmaskeringsresultatet med fjädring baserat på bildstorlek, modifierar de erhållna standardstrokarna och använder dem för den nya maskeringsiterationen. Bildmaskering utförs med automatiskt beräknade standardstrokar. Dessutom anges data för de två antagna objekten i AssumedObjects‑egenskapen för AutoMaskingGraphCutOptions. Efter att ha fått det initiala maskeringsresultatet modifieras de tillämpade bakgrunds‑/förgrundsstrokarna och en ytterligare maskeringsiteration utförs med en ny GraphCutMaskingOptions‑instans.

List<AssumedObjectData> assumedObjects = new LinkedList<AssumedObjectData>();
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Human, new Rectangle(100, 100, 150, 300)));
assumedObjects.add(new AssumedObjectData(DetectedObjectType.Dog, new Rectangle(300, 100, 50, 30)));

MaskingResult[] results;
AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions();
try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        options.setAssumedObjects(assumedObjects);
        options.setCalculateDefaultStrokes(true);
        options.setFeatheringRadius(3);
        options.setMethod(SegmentationMethod.GraphCut);
        options.setDecompose(false);
        options.setExportOptions(pngOptions);
        options.setBackgroundReplacementColor(Color.getTransparent());

        results = new ImageMasking(image).decompose(options);
    }
}

// Vid detta tillfälle kan de tillämpade förgrunds-/bakgrundsstrecken analyseras och baserat på dem ytterligare
// förgrunds-/bakgrundsstrecken kan tillhandahållas manuellt.

Point[] appliedBackgroundStrokes = options.getDefaultBackgroundStrokes();
Point[] appliedForegroundStrokes = options.getDefaultForegroundStrokes();
Rectangle[] appliedObjectRectangles = options.getDefaultObjectsRectangles();
try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

appliedBackgroundStrokes[5] = new Point(100, 100);
appliedBackgroundStrokes[15] = new Point(150, 100);

appliedForegroundStrokes[1] = new Point(500, 200);

appliedObjectRectangles[0] = new Rectangle(100, 100, 300, 300);

try (RasterImage image = (RasterImage)Image.load("input.jpg"))
{
    try (PngOptions pngOptions = new PngOptions())
    {
        pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
        pngOptions.setSource(new FileCreateSource("tempFile"));

        AutoMaskingArgs args = new AutoMaskingArgs();
        args.setObjectsPoints(new Point[][]
                {
                        appliedBackgroundStrokes,
                        appliedForegroundStrokes
                });

        args.setObjectsRectangles(appliedObjectRectangles);
                    
        GraphCutMaskingOptions graphCutOptions = new GraphCutMaskingOptions();
        graphCutOptions.setFeatheringRadius(3);
        graphCutOptions.setMethod(SegmentationMethod.GraphCut);
        graphCutOptions.setDecompose(false);
        graphCutOptions.setExportOptions(pngOptions);
        graphCutOptions.setBackgroundReplacementColor(Color.getTransparent());
        graphCutOptions.setArgs(args);
                    
        results = new ImageMasking(image).decompose(graphCutOptions);
    }
}

try (RasterImage resultImage = (RasterImage)results[1].getImage())
{
    PngOptions pngOptions = new PngOptions();
    pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
    resultImage.save("output.png", pngOptions);
}

// frisläpp resurser
for (MaskingResult res : results)
{
    res.close();
}

getPrecalculationProgressEventHandler()

public final ProgressEventHandler getPrecalculationProgressEventHandler()

Hämtar standardpunkternas förberäkningsprocessens framstegshändelsehanterare.

Värde: Progress‑händelsehanteraren.

Returns: ProgressEventHandler - the default points pre-calculation process progress event handler.

setPrecalculationProgressEventHandler(ProgressEventHandler value)

public final void setPrecalculationProgressEventHandler(ProgressEventHandler value)

Ställer in standardpunkternas förberäkningsprocessens framstegshändelsehanterare.

Värde: Progress‑händelsehanteraren.

Parameters:

Parameter	Typ	Beskrivning
value	ProgressEventHandler	standardpunkternas förberäkningsprocessens framstegshändelsehanterare.