Magic Cube

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

// Copyright 2022 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// 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;

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

class BandagedCreatorWorkerThread extends Thread

  {

  private static Vector<WorkLoad> mBuffers;

  private static BandagedCreatorWorkerThread mThis=null;

  private static WeakReference<Activity> mWeakAct;

  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;

      }

    }

  private int mCreatedBufSize;

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

  private BandagedCreatorWorkerThread()

    {

    }

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

  static void create(Activity act)

    {

    mWeakAct = new WeakReference<>(act);

    if( mThis==null )

      {

      mBuffers = new Vector<>();

      mThis = new BandagedCreatorWorkerThread();

      mThis.start();

      }

    }

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

  public void run()

    {

    WorkLoad load;

    while(true)

      {

      synchronized(mThis)

        {

        while( mBuffers.size()>0 )

          {

          load = mBuffers.remove(0);

          process(load);

          }

        try  { mThis.wait(); }

        catch(InterruptedException ignored) { }

        }

      }

    }

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

  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();

      }

    }

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

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

    {

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

      {

      if( tmp[4*i]==0 && tmp[4*i+3]==-1 ) return 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;

      }

    return -1;

    }

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

  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);

      if( firstBlackPixel(tmp,width)>=0 ) return i;

      }

    return 0;

    }

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

  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);

      if( firstBlackPixel(tmp,width)>=0 ) return i;

      }

    return width-1;

    }

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

  private int computeLeftColumn(ByteBuffer buf, byte[] tmp, int width, int firstrow, int lastrow)

    {

    int wBytes = 4*width;

    int currentBest = width;

    for(int i=firstrow; i<lastrow; i++)

      {

      buf.position(i*wBytes);

      buf.get(tmp);

      int pixel = firstBlackPixel(tmp,width);

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

      }

    return currentBest;

    }

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

  private int computeRightColumn(ByteBuffer buf, byte[] tmp, int width, int firstrow, int lastrow)

    {

    int wBytes = 4*width;

    int currentBest = 0;

    for(int i=firstrow; i<lastrow; i++)

      {

      buf.position(i*wBytes);

      buf.get(tmp);

      int pixel = lastBlackPixel(tmp,width);

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

      }

    return currentBest;

    }

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

// GL uses a coordinate system from mathematics; i.e. (0,0) is in the lower-left corner. 2D stuff

// 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.

  private ByteBuffer adjustBuffer(ByteBuffer input, byte[] tmp, int width, int height)

    {

    int firstRow   = computeFirstRow(input,tmp,width,height);

    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);

      }

/*

    if( sL==size && sR==size && sT==size && sB==size )

      {

      android.util.Log.e("D", "EVERYTHING ALL RIGHT centerX="+centerX+" centerY="+centerY+" size="+size);

      }

*/

    int minH = Math.min(sL,sR);

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

    mCreatedBufSize = Math.min(minH,minV);

    half = mCreatedBufSize/2;

    int wBytes = 4*mCreatedBufSize;

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

    output.order(ByteOrder.LITTLE_ENDIAN);

    int startRow = centerY+half;

    int distR = width-centerX-half;

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

      {

      input.position((startRow-i)*4*width + 4*distR );

      input.get(tmp,0,wBytes);

      output.position(i*wBytes);

      output.put(tmp,0,wBytes);

      }

    output.rewind();

    return output;

    }

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

  private void process(WorkLoad load)

    {

    int width  = load.width;

    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));

      Bitmap bmp = Bitmap.createBitmap( mCreatedBufSize, mCreatedBufSize, Bitmap.Config.ARGB_8888);

      bmp.copyPixelsFromBuffer(bufSquare);

      bmp.compress(Bitmap.CompressFormat.PNG, 90, bos);

      BandagedCreatorActivity cact = (BandagedCreatorActivity)act;

      cact.iconCreationDone(bmp);

      }

    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(); }

        catch(IOException ignored) {}

        }

      }

    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);

    }

  }