public void checkParentForResources(final PdfObject pdfObject) {

    /** if no resource, check parent for one (in theory should recurse up whole tree) */
    if (pdfObject.getDictionary(PdfDictionary.Resources) == null) {

      final String parent = pdfObject.getStringKey(PdfDictionary.Parent);

      if (parent != null) {
        final PdfObject parentObj = new PageObject(parent);
        readObject(parentObj);

        final PdfObject resObj = parentObj.getDictionary(PdfDictionary.Resources);

        if (resObj != null) {
          pdfObject.setDictionary(PdfDictionary.Resources, resObj);
        }
      }
    }
  }
  public BufferedImage convert(
      final DecoderResults resultsFromDecode,
      final int displayRotation,
      final PdfResources res,
      final ExternalHandlers externalHandlers,
      final int renderMode,
      final PdfPageData pageData,
      final AcroRenderer formRenderer,
      final float scaling,
      final PdfObjectReader currentPdfFile,
      final int pageIndex,
      final boolean imageIsTransparent,
      final String currentPageOffset)
      throws PdfException {

    final ObjectStore localStore = new ObjectStore();

    /** read page or next pages */
    final PdfObject pdfObject = new PageObject(currentPageOffset);
    currentPdfFile.readObject(pdfObject);

    currentPdfFile.checkParentForResources(pdfObject);

    // ensure set (needed for XFA)
    pdfObject.setPageNumber(pageIndex);

    final PdfObject Resources = pdfObject.getDictionary(PdfDictionary.Resources);

    imageDisplay = getDisplay(pageIndex, localStore, imageIsTransparent);

    if (!imageDisplay.isHTMLorSVG()) {

      if (options.getPageColor() != null) {
        imageDisplay.setValue(
            DynamicVectorRenderer.ALT_BACKGROUND_COLOR, options.getPageColor().getRGB());
      }

      if (options.getTextColor() != null) {
        imageDisplay.setValue(
            DynamicVectorRenderer.ALT_FOREGROUND_COLOR, options.getTextColor().getRGB());

        if (options.getChangeTextAndLine()) {
          imageDisplay.setValue(DynamicVectorRenderer.FOREGROUND_INCLUDE_LINEART, 1);
        } else {
          imageDisplay.setValue(DynamicVectorRenderer.FOREGROUND_INCLUDE_LINEART, 0);
        }

        imageDisplay.setValue(
            DynamicVectorRenderer.COLOR_REPLACEMENT_THRESHOLD,
            options.getReplacementColorThreshold());
      }
    }

    final PdfStreamDecoder currentImageDecoder =
        formRenderer.getStreamDecoder(currentPdfFile, true, null, true);

    currentImageDecoder.setParameters(
        true,
        true,
        renderMode,
        PdfDecoderInt.TEXT,
        false,
        externalHandlers.getMode().equals(GUIModes.JAVAFX));

    externalHandlers.addHandlers(currentImageDecoder);

    // currentImageDecoder.setObjectValue(ValueTypes.Name, filename);
    currentImageDecoder.setObjectValue(ValueTypes.ObjectStore, localStore);
    currentImageDecoder.setMultiplyer(multiplyer);
    currentImageDecoder.setObjectValue(ValueTypes.PDFPageData, pageData);
    currentImageDecoder.setIntValue(ValueTypes.PageNum, pageIndex);

    currentImageDecoder.setRenderer(imageDisplay);
    externalHandlers.addHandlers(currentImageDecoder);

    res.setupResources(currentImageDecoder, true, Resources, pageIndex, currentPdfFile);

    // can for max
    if (multiplyer == -2) {

      multiplyer = -1;
      currentImageDecoder.setMultiplyer(multiplyer);

      final PdfStreamDecoderForSampling currentImageDecoder2 =
          new PdfStreamDecoderForSampling(currentPdfFile);
      currentImageDecoder2.setParameters(
          true, true, renderMode, 0, false, externalHandlers.getMode().equals(GUIModes.JAVAFX));

      // currentImageDecoder2.setObjectValue(ValueTypes.Name, filename);
      currentImageDecoder2.setObjectValue(ValueTypes.ObjectStore, localStore);
      currentImageDecoder2.setMultiplyer(multiplyer);
      currentImageDecoder2.setObjectValue(ValueTypes.PDFPageData, pageData);
      currentImageDecoder2.setIntValue(ValueTypes.PageNum, pageIndex);
      currentImageDecoder2.setRenderer(imageDisplay);

      res.setupResources(currentImageDecoder2, true, Resources, pageIndex, currentPdfFile);

      externalHandlers.addHandlers(currentImageDecoder2);

      /** bare minimum to get value */
      multiplyer = currentImageDecoder2.decodePageContentForImageSampling(pdfObject);

      int bestQualityMaxScalingToUse = 0;
      if (instance_bestQualityMaxScaling != null) {
        bestQualityMaxScalingToUse = instance_bestQualityMaxScaling;
      } else if (bestQualityMaxScaling != null) {
        bestQualityMaxScalingToUse = bestQualityMaxScaling;
      }

      if (bestQualityMaxScalingToUse > 0 && multiplyer > bestQualityMaxScalingToUse) {
        multiplyer = bestQualityMaxScalingToUse;
      }

      currentImageDecoder2.setMultiplyer(multiplyer);
      currentImageDecoder.setMultiplyer(multiplyer);
    }

    if (!allowPagesSmallerThanPageSize
        && !instance_allowPagesSmallerThanPageSize
        && multiplyer < 1
        && multiplyer > 0) {
      multiplyer = 1;
    }

    // allow for value not set
    if (multiplyer == -1) {
      multiplyer = 1;
    }

    /** setup positions,transformations and image */
    imageScaling =
        PDFtoImageConvertorSwing.setPageParametersForImage(
            scaling * multiplyer, pageIndex, pageData);

    setParams(scaling, pageData, pageIndex);

    final BufferedImage image =
        pageToImage(imageIsTransparent, currentImageDecoder, scaling, pdfObject, formRenderer);

    resultsFromDecode.update(currentImageDecoder, false);

    /** draw acroform data onto Panel */
    if (formRenderer != null
        && formRenderer.hasFormsOnPage(pageIndex)
        && !formRenderer.ignoreForms()) {

      resultsFromDecode.resetColorSpaces();

      if (!formRenderer.getCompData().hasformsOnPageDecoded(pageIndex)) {
        formRenderer.createDisplayComponentsForPage(pageIndex, currentImageDecoder);
      }

      if (isFX) {
        // done in fx image code
      } else if (!formRenderer.getCompData().formsRasterizedForDisplay()) {

        if (!formRenderer.useXFA()) {

          java.util.List[] formsOrdered = formRenderer.getCompData().getFormList(true);

          // get unsorted components and iterate over forms
          for (Object nextVal : formsOrdered[pageIndex]) {

            if (nextVal != null) {
              formRenderer
                  .getFormFlattener()
                  .drawFlattenedForm(
                      currentImageDecoder,
                      (org.jpedal.objects.raw.FormObject) nextVal,
                      false,
                      (PdfObject) formRenderer.getFormResources()[0]);
            }
          }

        } else {
          formRenderer
              .getCompData()
              .renderFormsOntoG2(
                  image.getGraphics(),
                  pageIndex,
                  0,
                  displayRotation,
                  null,
                  null,
                  pageData.getMediaBoxHeight(pageIndex));
        }
      } else {

        final java.util.List[] formsOrdered = formRenderer.getCompData().getFormList(true);

        // get unsorted components and iterate over forms
        for (final Object nextVal : formsOrdered[pageIndex]) {

          if (nextVal != null) {

            formRenderer
                .getFormFlattener()
                .drawFlattenedForm(
                    currentImageDecoder,
                    (org.jpedal.objects.raw.FormObject) nextVal,
                    false,
                    (PdfObject) formRenderer.getFormResources()[0]);
          }
        }
      }
    }

    if (currentImageDecoder != null) {
      currentImageDecoder.dispose();
    }

    localStore.flush();
    return image;
  }