Magic Cube

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2022 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

package org.distorted.bandaged;

import android.app.Activity;

import android.content.Intent;

import android.graphics.Bitmap;

import android.net.Uri;

import android.widget.Toast;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.lang.ref.WeakReference;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.util.Vector;

///////////////////////////////////////////////////////////////////////////////////////////////////

  private static Vector<WorkLoad> mBuffers;

  private static class WorkLoad

    {

    ByteBuffer buffer;

    int width;

    int height;

    int numColors;

    String filename;

    WorkLoad(ByteBuffer buf, int w, int h, int n, String name)

      {

      buffer   = buf;

      width    = w;

      height   = h;

      numColors= n;

      filename = name;

      }

    }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  static void create(Activity act)

    {

    mWeakAct = new WeakReference<>(act);

    if( mThis==null )

      {

      mBuffers = new Vector<>();

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void run()

    {

    WorkLoad load;

    while(true)

      {

      synchronized(mThis)

        {

        while( mBuffers.size()>0 )

          {

          load = mBuffers.remove(0);

          process(load);

          }

        try  { mThis.wait(); }

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  static void newBuffer(ByteBuffer buffer, int width, int height, int numColors, String filename)

    {

    synchronized(mThis)

      {

      WorkLoad load = new WorkLoad(buffer,width,height,numColors,filename);

      mBuffers.add(load);

      mThis.notify();

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

    for(int i=0; i<width; i++)

      {

      }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int lastBlackPixel(byte[] tmp, int width)

    {

    for(int i=width-1; i>=0; i--)

      {

      if( tmp[4*i]==0 && tmp[4*i+3]==-1 ) return i;

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int computeFirstRow(ByteBuffer buf, byte[] tmp, int width, int height)

    {

    int wBytes = 4*width;

    for(int i=0; i<height; i++)

      {

      buf.position(i*wBytes);

      buf.get(tmp);

///////////////////////////////////////////////////////////////////////////////////////////////////

  private int computeLastRow(ByteBuffer buf, byte[] tmp, int width, int height)

    {

    int wBytes = 4*width;

    for(int i=height-1; i>=0; i--)

      {

      buf.position(i*wBytes);

      buf.get(tmp);

///////////////////////////////////////////////////////////////////////////////////////////////////

    int wBytes = 4*width;

      buf.get(tmp);

      int pixel = firstBlackPixel(tmp,width);

      if( pixel>=0 && pixel<currentBest ) currentBest = pixel;

///////////////////////////////////////////////////////////////////////////////////////////////////

    int currentBest = 0;

      buf.get(tmp);

      int pixel = lastBlackPixel(tmp,width);

      if( pixel>=0 && pixel>currentBest ) currentBest = pixel;

    return currentBest;

///////////////////////////////////////////////////////////////////////////////////////////////////

// has the origin on the upper-left corner; we have to flip our bitmap upside down!

//

// We also need to figure out the topmost and bottommost rows where the object starts and cut out

// a square section from the 'input' so that the object is vertically centralized.

    int lastRow    = computeLastRow(input,tmp,width,height);

    int leftColumn = computeLeftColumn(input,tmp,width,firstRow,lastRow);

    int rightColumn= computeRightColumn(input,tmp,width,firstRow,lastRow);

    int rowHeight = lastRow-firstRow;

    int colWidth  = rightColumn-leftColumn;

    int size      = Math.max(rowHeight,colWidth);

    size = (int)(1.1f*size);

    int half = size/2;

    int centerX = (leftColumn+rightColumn)/2;

    int centerY = (firstRow+lastRow)/2;

    int sL=size, sR=size, sT=size, sB=size;

    if( centerX-half<    0 )

      {

      android.util.Log.e("D", "buffer encroaches on the left!   centerX="+centerX+" centerY="+centerY+" size="+size);

      sL = 2*centerX;

      }

    if( centerX+half>width )

      {

      android.util.Log.e("D", "buffer encroaches on the right!  centerX="+centerX+" centerY="+centerY+" size="+size);

      sR = 2*(width-centerX);

      }

    if( centerY-half<    0 )

      {

      android.util.Log.e("D", "buffer encroaches on the top!    centerX="+centerX+" centerY="+centerY+" size="+size);

      sT = 2*centerY;

      }

    if( centerY+half>height)

      {

      android.util.Log.e("D", "buffer encroaches on the bottom! centerX="+centerX+" centerY="+centerY+" size="+size);

      sB = 2*(height-centerY);

      }

    int minV = Math.min(sT,sB);

    mCreatedBufSize = Math.min(minH,minV);

    half = mCreatedBufSize/2;

    int wBytes = 4*mCreatedBufSize;

    ByteBuffer output = ByteBuffer.allocateDirect(wBytes*mCreatedBufSize);

    int distR = width-centerX-half;

      input.get(tmp,0,wBytes);

    output.rewind();

    return output;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void process(WorkLoad load)

    {

    int height = load.height;

    byte[] tmp = new byte[4*width];

    ByteBuffer bufSquare = adjustBuffer(load.buffer,tmp,width,height);

    final String filename = load.filename;

    BufferedOutputStream bos =null;

    final Activity act = mWeakAct.get();

    try

      {

      bos = new BufferedOutputStream(new FileOutputStream(filename));

      }

    catch(final Exception ex)

      {

      act.runOnUiThread(new Runnable()

        {

        public void run()

          {

          Toast.makeText(act,

              "Saving to \n\n"+filename+"\n\n failed: "+"\n\n"+ex.getMessage() ,

              Toast.LENGTH_LONG).show();

          }

        });

      }

    finally

      {

      if(bos!=null)

        {

        try { bos.close(); }

      }

    Intent mediaScanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);

    File f = new File(filename);

    Uri contentUri = Uri.fromFile(f);

    mediaScanIntent.setData(contentUri);

    act.sendBroadcast(mediaScanIntent);

    }

  }