Home | History | Annotate | Download | only in jni 
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <jni.h>
     18 #include <math.h>
     19 #include <android/bitmap.h>
     20 
     21 #ifdef __cplusplus
     22 extern "C" {
     23 #endif
     24 
     25 
     26 #define PI_F 3.141592653589f
     27 
     28 class ImageRGBA {
     29  public:
     30   ImageRGBA(unsigned char* image, int width, int height)
     31    : image_(image), width_(width), height_(height) {
     32     width_step_ = width * 4;
     33   }
     34 
     35   int Width() const {
     36     return width_;
     37   }
     38 
     39   int Height() const {
     40     return height_;
     41   }
     42 
     43   // Pixel accessor.
     44   unsigned char* operator()(int x, int y) {
     45     return image_ + y * width_step_ + x * 4;
     46   }
     47   const unsigned char* operator()(int x, int y) const {
     48     return image_ + y * width_step_ + x * 4;
     49   }
     50 
     51  private:
     52   unsigned char* image_;
     53   int width_;
     54   int height_;
     55   int width_step_;
     56 };
     57 
     58 // Interpolate a pixel in a 3 channel image.
     59 inline void InterpolatePixel(const ImageRGBA &image, float x, float y,
     60                              unsigned char* dest) {
     61   // Get pointers and scale factors for the source pixels.
     62   float ax = x - floor(x);
     63   float ay = y - floor(y);
     64   float axn = 1.0f - ax;
     65   float ayn = 1.0f - ay;
     66   const unsigned char *p = image(x, y);
     67   const unsigned char *p2 = image(x, y + 1);
     68 
     69   // Interpolate each image color plane.
     70   dest[0] = static_cast<unsigned char>(axn * ayn * p[0] + ax * ayn * p[4] +
     71              ax * ay * p2[4] + axn * ay * p2[0] + 0.5f);
     72   p++;
     73   p2++;
     74 
     75   dest[1] = static_cast<unsigned char>(axn * ayn * p[0] + ax * ayn * p[4] +
     76              ax * ay * p2[4] + axn * ay * p2[0] + 0.5f);
     77   p++;
     78   p2++;
     79 
     80   dest[2] = static_cast<unsigned char>(axn * ayn * p[0] + ax * ayn * p[4] +
     81              ax * ay * p2[4] + axn * ay * p2[0] + 0.5f);
     82   p++;
     83   p2++;
     84   dest[3] = 0xFF;
     85 }
     86 
     87 // Wrap circular coordinates around the globe
     88 inline float wrap(float value, float dimension) {
     89   return value - (dimension * floor(value/dimension));
     90 }
     91 
     92 void StereographicProjection(float scale, float angle, unsigned char* input_image,
     93                              int input_width, int input_height,
     94                              unsigned char* output_image, int output_width,
     95                              int output_height) {
     96   ImageRGBA input(input_image, input_width, input_height);
     97   ImageRGBA output(output_image, output_width, output_height);
     98 
     99   const float image_scale = output_width * scale;
    100 
    101   for (int x = 0; x < output_width; x++) {
    102     // Center and scale x
    103     float xf = (x - output_width / 2.0f) / image_scale;
    104 
    105     for (int y = 0; y < output_height; y++) {
    106       // Center and scale y
    107       float yf = (y - output_height / 2.0f) / image_scale;
    108 
    109       // Convert to polar
    110       float r = hypotf(xf, yf);
    111       float theta = angle+atan2(yf, xf);
    112       if (theta>PI_F) theta-=2*PI_F;
    113 
    114       // Project onto plane
    115       float phi = 2 * atan(1 / r);
    116       // (theta stays the same)
    117 
    118       // Map to panorama image
    119       float px = (theta / (2 * PI_F)) * input_width;
    120       float py = (phi / PI_F) * input_height;
    121 
    122       // Wrap around the globe
    123       px = wrap(px, input_width);
    124       py = wrap(py, input_height);
    125 
    126       // Write the interpolated pixel
    127       InterpolatePixel(input, px, py, output(x, y));
    128     }
    129   }
    130 }
    131 
    132 
    133 JNIEXPORT void JNICALL Java_com_android_camera_tinyplanet_TinyPlanetNative_process(JNIEnv* env, jobject obj, jobject bitmap_in, jint width, jint height, jobject bitmap_out, jint output_size, jfloat scale, jfloat angle)
    134 {
    135     char* source = 0;
    136     char* destination = 0;
    137     AndroidBitmap_lockPixels(env, bitmap_in, (void**) &source);
    138     AndroidBitmap_lockPixels(env, bitmap_out, (void**) &destination);
    139     unsigned char * rgb_in = (unsigned char * )source;
    140     unsigned char * rgb_out = (unsigned char * )destination;
    141 
    142     StereographicProjection(scale, angle, rgb_in, width, height, rgb_out, output_size, output_size);
    143     AndroidBitmap_unlockPixels(env, bitmap_in);
    144     AndroidBitmap_unlockPixels(env, bitmap_out);
    145 }
    146 
    147 #ifdef __cplusplus
    148 }
    149 #endif
    150 
    151 
    152