C++ Dimensions::elementCount方法代码示例

void crop_and_flip_image(Buffer* destBuffer, Buffer* sourceBuffer, int offsetX, int offsetY, bool doFlipHorizontal) {

  const Dimensions destDims = destBuffer->_dims;
  const Dimensions sourceDims = sourceBuffer->_dims;
  assert((destDims._length == 3) && (sourceDims._length == 3));

  const int destWidth = destDims[1];
  const int destHeight = destDims[0];
  const int destChannels = destDims[2];

  const int sourceWidth = sourceDims[1];
  const int sourceHeight = sourceDims[0];
  const int sourceChannels = sourceDims[2];
  assert(destChannels == sourceChannels);

  const int sourceEndX = (offsetX + destWidth);
  assert(sourceEndX <= sourceWidth);
  const int sourceEndY = (offsetY + destHeight);
  assert(sourceEndY <= sourceHeight);

  const Dimensions destRowDims = destDims.removeDimensions(1);
  const int destRowElementCount = destRowDims.elementCount();
  const size_t destRowByteCount = (destRowElementCount * sizeof(jpfloat_t));

  jpfloat_t* const destDataStart = destBuffer->_data;
  jpfloat_t* const sourceDataStart = sourceBuffer->_data;

  if (!doFlipHorizontal) {
    for (int destY = 0; destY < destHeight; destY += 1) {
      const int sourceX = offsetX;
      const int sourceY = (destY + offsetY);
      const int sourceOffset = sourceDims.offset(sourceY, sourceX, 0);
      jpfloat_t* const sourceData = (sourceDataStart + sourceOffset);
      const int destOffset = destDims.offset(destY, 0, 0);
      jpfloat_t* const destData = (destDataStart + destOffset);
      memcpy(destData, sourceData, destRowByteCount);
    }
  } else {
    for (int destY = 0; destY < destHeight; destY += 1) {
      const int sourceX = offsetX;
      const int sourceY = (destY + offsetY);
      const int sourceOffset = sourceDims.offset(sourceY, sourceX, 0);
      jpfloat_t* const sourceLeft = (sourceDataStart + sourceOffset);
      const int destOffset = destDims.offset(destY, 0, 0);
      jpfloat_t* const destLeft = (destDataStart + destOffset);
      jpfloat_t* const destRight = (destLeft + destRowElementCount);
      jpfloat_t* destCurrent = destRight;
      jpfloat_t* sourceCurrent = sourceLeft;
      while (destCurrent != destLeft) {
        jpfloat_t* destChannelEnd = (destCurrent + destChannels);
        while (destCurrent < destChannelEnd) {
          *destCurrent = *sourceCurrent;
          destCurrent += 1;
          sourceCurrent += 1;
        }
        destCurrent -= (destChannels * 2);
      }
    }
  }

}

void rescale_image_to_fit(Buffer* input, Buffer* output, bool doFlip) {

  const Dimensions inputDims = input->_dims;
  const int inputWidth = inputDims[1];
  const int inputHeight = inputDims[0];
  const int inputChannels = inputDims[2];

  const Dimensions outputDims = output->_dims;
  const int outputWidth = outputDims[1];
  const int outputHeight = outputDims[0];
  const int outputChannels = outputDims[2];

  if ((inputDims == outputDims) && !doFlip) {
    const int elementCount = inputDims.elementCount();
    const size_t bytesInBuffer = (elementCount * sizeof(jpfloat_t));
    memcpy(output->_data, input->_data, bytesInBuffer);
    return;
  }

  const float flipBias = (doFlip) ? inputHeight : 0.0f;
  const float flipScale = (doFlip) ? -1.0f : 1.0f;

  const float scaleX = (inputWidth / (jpfloat_t)(outputWidth));
  const float scaleY = (flipScale * (inputHeight / (jpfloat_t)(outputHeight)));
  const int channelsToWrite = MIN(outputChannels, inputChannels);

  const Dimensions inputRowDims = inputDims.removeDimensions(1);
  const Dimensions outputRowDims = outputDims.removeDimensions(1);

  const jpfloat_t* inputDataStart = input->_data;
  jpfloat_t* const outputDataStart = output->_data;

  for (int outputY = 0; outputY < outputHeight; outputY += 1) {
    const jpfloat_t inputY = (flipBias + (outputY * scaleY));
    const int indexY0 = fmaxf(0.0f, fminf((inputHeight - 1.0f), floorf(inputY)));
    const int indexY1 = fmaxf(0.0f, fminf((inputHeight - 1.0f), ceilf(inputY)));
    const jpfloat_t lerpY = (indexY1 - inputY);
    const jpfloat_t oneMinusLerpY = (1.0f - lerpY);

    const int inputRowY0Offset = inputDims.offset(indexY0, 0, 0);
    const jpfloat_t* const inputRowY0 = (inputDataStart + inputRowY0Offset);
    const int inputRowY1Offset = inputDims.offset(indexY1, 0, 0);
    const jpfloat_t* const inputRowY1 = (inputDataStart + inputRowY1Offset);
    const int outputRowOffset = outputDims.offset(outputY, 0, 0);
    jpfloat_t* const outputRow = (outputDataStart + outputRowOffset);

    for (int outputX = 0; outputX < outputWidth; outputX += 1) {
      const jpfloat_t inputX = (outputX * scaleX);
      const int indexX0 = fmaxf(0.0f, floorf(inputX));
      const int indexX1 = fminf((inputWidth - 1.0f), ceilf(inputX));
      const jpfloat_t lerpX = (indexX1 - inputX);
      const jpfloat_t oneMinusLerpX = (1.0f - lerpX);

      const int indexX0Offset = inputRowDims.offset(indexX0, 0);
      const int indexX1Offset = inputRowDims.offset(indexX1, 0);

      const jpfloat_t* const input00Base = (inputRowY0 + indexX0Offset);
      const jpfloat_t* const input01Base = (inputRowY0 + indexX1Offset);
      const jpfloat_t* const input10Base = (inputRowY1 + indexX0Offset);
      const jpfloat_t* const input11Base = (inputRowY1 + indexX1Offset);

      const int outputOffset = outputRowDims.offset(outputX, 0);
      jpfloat_t* const outputBase = (outputRow + outputOffset);

      for (int channel = 0; channel < outputChannels; channel += 1) {
        jpfloat_t* const outputLocation = (outputBase + channel);
        if (channel >= channelsToWrite) {
          *outputLocation = 0.0f;
        } else {
          const jpfloat_t* input00Location = (input00Base + channel);
          const jpfloat_t* input01Location = (input01Base + channel);
          const jpfloat_t* input10Location = (input10Base + channel);
          const jpfloat_t* input11Location = (input11Base + channel);

          const jpfloat_t input00 = (*input00Location);
          const jpfloat_t input01 = (*input01Location);
          const jpfloat_t input10 = (*input10Location);
          const jpfloat_t input11 = (*input11Location);

          const jpfloat_t yInterp0 = ((input00 * lerpY) + (input10 * oneMinusLerpY));
          const jpfloat_t yInterp1 = ((input01 * lerpY) + (input11 * oneMinusLerpY));
          const jpfloat_t interp = ((yInterp0 * lerpX) + (yInterp1 * oneMinusLerpX));
          *outputLocation = interp;
        }
      }

    }
  }
}