Beispiel #1
0
  public static void randomToolActions(int numStrokes, boolean brushOnly) {
    Composition comp = ImageComponents.getActiveComp().get();
    Random random = new Random();

    if (comp != null) {
      int canvasWidth = comp.getCanvasWidth();
      int canvasHeight = comp.getCanvasHeight();

      ProgressMonitor progressMonitor = Utils.createPercentageProgressMonitor("1001 Tool Actions");

      // So far we are on the EDT
      Runnable notEDTThreadTask =
          () -> {
            assert !SwingUtilities.isEventDispatchThread();
            for (int i = 0; i < numStrokes; i++) {
              int progressPercentage = (int) ((float) i * 100 / numStrokes);
              progressMonitor.setProgress(progressPercentage);
              progressMonitor.setNote(progressPercentage + "%");

              Runnable edtRunnable =
                  () -> testToolAction(comp, random, canvasWidth, canvasHeight, brushOnly);

              try {
                SwingUtilities.invokeAndWait(edtRunnable);
              } catch (InterruptedException | InvocationTargetException e) {
                e.printStackTrace();
              }

              comp.repaint();
            }
            progressMonitor.close();
          };
      new Thread(notEDTThreadTask).start();
    }
  }
Beispiel #2
0
  public static void saveManySplashImages() {
    boolean okPressed = SingleDirChooserPanel.selectOutputDir(true);
    if (!okPressed) {
      return;
    }

    ProgressMonitor progressMonitor =
        Utils.createPercentageProgressMonitor("Save Many Splash Images", "Stop");

    SwingWorker<Void, Void> worker =
        new SwingWorker<Void, Void>() {
          @Override
          public Void doInBackground() {
            int nurOfSplashImages = 32;

            for (int i = 0; i < nurOfSplashImages; i++) {
              OutputFormat outputFormat = OutputFormat.getLastOutputFormat();

              String fileName = String.format("splash%04d.%s", i, outputFormat.toString());

              progressMonitor.setProgress((int) ((float) i * 100 / nurOfSplashImages));
              progressMonitor.setNote("Creating " + fileName);
              if (progressMonitor.isCanceled()) {
                break;
              }

              Runnable guiTask =
                  () -> {
                    createSplashImage();

                    File lastSaveDir = FileChoosers.getLastSaveDir();
                    File f = new File(lastSaveDir, fileName);

                    Composition comp = ImageComponents.getActiveComp().get();

                    outputFormat.saveComposition(comp, f, false);

                    ImageComponents.getActiveIC().close();
                    ValueNoise.reseed();
                  };
              try {
                EventQueue.invokeAndWait(guiTask);
                Thread.sleep(1000L);
              } catch (InterruptedException | InvocationTargetException e) {
                Messages.showException(e);
              }
            } // end of for loop
            progressMonitor.close();
            return null;
          } // end of doInBackground()
        };
    worker.execute();
  }
Beispiel #3
0
 @BeforeClass
 public static void initialize() {
   cleanOutputs();
   checkTestingDirs();
   Utils.checkThatAssertionsAreEnabled();
 }
Beispiel #4
0
  public static Composition readOpenRaster(File file)
      throws IOException, ParserConfigurationException, SAXException {
    boolean DEBUG = System.getProperty("openraster.debug", "false").equals("true");

    String stackXML = null;
    Map<String, BufferedImage> images = new HashMap<>();
    try (ZipFile zipFile = new ZipFile(file)) {
      Enumeration<? extends ZipEntry> fileEntries = zipFile.entries();
      while (fileEntries.hasMoreElements()) {
        ZipEntry entry = fileEntries.nextElement();
        String name = entry.getName();

        if (name.equalsIgnoreCase("stack.xml")) {
          stackXML = extractString(zipFile.getInputStream(entry));
        } else if (name.equalsIgnoreCase("mergedimage.png")) {
          // no need for that
        } else {
          String extension = FileExtensionUtils.getFileExtension(name);
          if ("png".equalsIgnoreCase(extension)) {
            BufferedImage image = ImageIO.read(zipFile.getInputStream(entry));
            images.put(name, image);
            if (DEBUG) {
              System.out.println(
                  String.format(
                      "OpenRaster::readOpenRaster: found png image in zip file at the path '%s'",
                      name));
            }
          }
        }
      }
    }

    if (stackXML == null) {
      throw new IllegalStateException("No stack.xml found.");
    }

    if (DEBUG) {
      System.out.println(String.format("OpenRaster::readOpenRaster: stackXML = '%s'", stackXML));
    }

    Document doc = loadXMLFromString(stackXML);
    Element documentElement = doc.getDocumentElement();
    documentElement.normalize();
    String documentElementNodeName = documentElement.getNodeName();
    if (!documentElementNodeName.equals("image")) {
      throw new IllegalStateException(
          String.format(
              "stack.xml root element is '%s', expected: 'image'", documentElementNodeName));
    }

    String w = documentElement.getAttribute("w");
    int compositionWidth = Integer.parseInt(w);
    String h = documentElement.getAttribute("h");
    int compositionHeight = Integer.parseInt(h);

    if (DEBUG) {
      System.out.println(
          String.format(
              "OpenRaster::readOpenRaster: w = '%s', h = '%s', compositionWidth = %d, compositionHeight = %d",
              w, h, compositionWidth, compositionHeight));
    }

    Composition comp = Composition.empty(compositionWidth, compositionHeight);
    comp.setFile(file);

    NodeList layers = documentElement.getElementsByTagName("layer");
    for (int i = layers.getLength() - 1;
        i >= 0;
        i--) { // stack.xml contains layers in reverse order
      Node node = layers.item(i);
      Element element = (Element) node;

      String layerName = element.getAttribute("name");
      String layerVisibility = element.getAttribute("visibility");
      String layerVisible = element.getAttribute("visible");
      String layerBlendingMode = element.getAttribute("composite-op");
      String layerOpacity = element.getAttribute("opacity");
      String layerImageSource = element.getAttribute("src");
      String layerX = element.getAttribute("x");
      String layerY = element.getAttribute("y");

      BufferedImage image = images.get(layerImageSource);
      image = ImageUtils.toCompatibleImage(image);

      if (DEBUG) {
        int imageWidth = image.getWidth();
        int imageHeight = image.getHeight();
        System.out.println(
            "OpenRaster::readOpenRaster: imageWidth = "
                + imageWidth
                + ", imageHeight = "
                + imageHeight);
        //                Utils.debugImage(image, layerImageSource);
      }

      if (layerVisibility == null || layerVisibility.isEmpty()) {
        // workaround: paint.net exported files use "visible" attribute instead of "visibility"
        layerVisibility = layerVisible;
      }
      boolean visibility = layerVisibility == null ? true : layerVisibility.equals("visible");

      ImageLayer layer = new ImageLayer(comp, image, layerName, null);
      layer.setVisible(visibility, AddToHistory.NO);
      BlendingMode blendingMode = BlendingMode.fromSVGName(layerBlendingMode);

      if (DEBUG) {
        System.out.println("OpenRaster::readOpenRaster: blendingMode = " + blendingMode);
      }

      layer.setBlendingMode(blendingMode, UpdateGUI.NO, AddToHistory.NO, false);
      float opacity = Utils.parseFloat(layerOpacity, 1.0f);
      layer.setOpacity(opacity, UpdateGUI.NO, AddToHistory.NO, false);
      int translationX = Utils.parseInt(layerX, 0);
      int translationY = Utils.parseInt(layerY, 0);
      // TODO assuming that there is no layer mask
      layer.setTranslation(translationX, translationY);

      if (DEBUG) {
        System.out.println(
            String.format(
                "OpenRaster::readOpenRaster: opacity = %.2f, translationX = %d, translationY = %d",
                opacity, translationX, translationY));
      }

      comp.addLayerNoGUI(layer);
    }
    comp.setActiveLayer(comp.getLayer(0), AddToHistory.NO);
    return comp;
  }
Beispiel #5
0
  public void execute(ChangeReason changeReason) {
    // only filters without a GUI call this

    Utils.executeFilterWithBusyCursor(this, changeReason, PixelitorWindow.getInstance());
  }