Java example source code file (mlib_ImageClipping.c)

This example Java source code file (mlib_ImageClipping.c) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

mlib_image_chan_equal, mlib_image_check, mlib_image_type_equal, mlib_success, null

The mlib_ImageClipping.c Java example source code

/*
 * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */


/*
 * FUNCTION
 *      mlib_ImageClipping
 *      mlib_ImageClippingMxN
 *              Clipping for image processing in case of pixel-to-pixel
 *              square kernel filtering. Source and destination images can have
 *              different sizes, center of the source is mapped to the center of
 *              the destination image.
 *              Examples of this type of image processing are Convolve, Gradient,
 *              Dilate/Erode functions, etc.
 *
 * SYNOPSIS
 *      mlib_status mlib_ImageClipping(mlib_image       *dst_i,
 *                                     mlib_image       *src_i,
 *                                     mlib_image       *dst_e,
 *                                     mlib_image       *src_e,
 *                                     mlib_s32         *edg_sizes,
 *                                     const mlib_image *dst,
 *                                     const mlib_image *src,
 *                                     mlib_s32         ker_size)
 *
 *      mlib_status mlib_ImageClippingMxN(mlib_image       *dst_i,
 *                                        mlib_image       *src_i,
 *                                        mlib_image       *dst_e,
 *                                        mlib_image       *src_e,
 *                                        mlib_s32         *edg_sizes,
 *                                        const mlib_image *dst,
 *                                        const mlib_image *src,
 *                                        mlib_s32         kw,
 *                                        mlib_s32         kh,
 *                                        mlib_s32         kw1,
 *                                        mlib_s32         kh1)
 *
 * OUTPUT ARGUMENTS
 *      dst_i     Pointer to destination image of internal pixels
 *      src_i     Pointer to source image of internal pixels
 *      dst_e     Pointer to destination image for edge processing
 *      src_e     Pointer to source image for edge processing
 *      edg_sizes Array of edge sizes
 *
 * INPUT ARGUMENTS
 *      dst       Pointer to destination image.
 *      src       Pointer to source image.
 *      ksize     Size of kernel
 *
 * RESTRICTION
 *      The src and the dst must be images of the same type.
 *      The src and dst must have same number of channels.
 *
 */

#include "mlib_image.h"
#include "mlib_ImageCheck.h"
#include "mlib_ImageClipping.h"
#include "mlib_ImageCreate.h"

/***************************************************************/
mlib_status mlib_ImageClippingMxN(mlib_image       *dst_i,
                                  mlib_image       *src_i,
                                  mlib_image       *dst_e,
                                  mlib_image       *src_e,
                                  mlib_s32         *edg_sizes,
                                  const mlib_image *dst,
                                  const mlib_image *src,
                                  mlib_s32         kw,
                                  mlib_s32         kh,
                                  mlib_s32         kw1,
                                  mlib_s32         kh1)
{
  mlib_s32  kw2 = kw - 1 - kw1;
  mlib_s32  kh2 = kh - 1 - kh1;
  mlib_s32  src_wid, src_hgt, dst_wid, dst_hgt;
  mlib_s32  dx, dy, dxd, dxs, dyd, dys, wid_e, hgt_e;
  mlib_s32  dx_l, dx_r, dy_t, dy_b, wid_i, hgt_i;

  MLIB_IMAGE_CHECK(dst);
  MLIB_IMAGE_CHECK(src);
  MLIB_IMAGE_TYPE_EQUAL(dst, src);
  MLIB_IMAGE_CHAN_EQUAL(dst, src);

  dst_wid = mlib_ImageGetWidth(dst);
  dst_hgt = mlib_ImageGetHeight(dst);
  src_wid = mlib_ImageGetWidth(src);
  src_hgt = mlib_ImageGetHeight(src);

  /* X clipping */
  dx = src_wid - dst_wid;

  if (dx > 0) {
    dxs = (dx + 1) >> 1;
    dxd = 0;
  } else {
    dxs = 0;
    dxd = (-dx) >> 1;
  }

  dx_l = kw1 - dxs;
  dx_r = kw2 + dxs - dx;

  if (dx_l < 0) dx_l = 0;
  if (dx_r < 0) dx_r = 0;
  if (dx_r > kw2) dx_r = kw2;

  /* Y clipping */
  dy = src_hgt - dst_hgt;

  if (dy > 0) {
    dys = (dy + 1) >> 1;
    dyd = 0;
  } else {
    dys = 0;
    dyd = (-dy) >> 1;
  }

  dy_t = kh1 - dys;
  dy_b = kh2 + dys - dy;

  if (dy_t < 0) dy_t = 0;
  if (dy_b < 0) dy_b = 0;
  if (dy_b > kh2) dy_b = kh2;

  /* image sizes */
  wid_e = (src_wid < dst_wid) ? src_wid : dst_wid;
  hgt_e = (src_hgt < dst_hgt) ? src_hgt : dst_hgt;
  wid_i = wid_e + (kw1 - dx_l) + (kw2 - dx_r);
  hgt_i = hgt_e + (kh1 - dy_t) + (kh2 - dy_b);

  mlib_ImageSetSubimage(dst_i, dst, dxd - (kw1 - dx_l), dyd - (kh1 - dy_t), wid_i, hgt_i);
  mlib_ImageSetSubimage(src_i, src, dxs - (kw1 - dx_l), dys - (kh1 - dy_t), wid_i, hgt_i);

  if (dst_e != NULL && src_e != NULL) { /* images for edge processing */
    mlib_ImageSetSubimage(dst_e, dst, dxd, dyd, wid_e, hgt_e);
    mlib_ImageSetSubimage(src_e, src, dxs, dys, wid_e, hgt_e);
  }

  if (edg_sizes != NULL) { /* save edges */
    edg_sizes[0] = dx_l;
    edg_sizes[1] = dx_r;
    edg_sizes[2] = dy_t;
    edg_sizes[3] = dy_b;
  }

  return MLIB_SUCCESS;
}

/***************************************************************/
mlib_status mlib_ImageClipping(mlib_image       *dst_i,
                               mlib_image       *src_i,
                               mlib_image       *dst_e,
                               mlib_image       *src_e,
                               mlib_s32         *edg_sizes,
                               const mlib_image *dst,
                               const mlib_image *src,
                               mlib_s32         ker_size)
{
  mlib_s32 kw1 = (ker_size - 1)/2;
  return mlib_ImageClippingMxN(dst_i, src_i, dst_e, src_e, edg_sizes,
                               dst, src, ker_size, ker_size, kw1, kw1);
}

/***************************************************************/