Magic Cube

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

// Copyright 2022 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted 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 for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

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 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 ex) { }

        }

      }

    }

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

  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 boolean containsBlackness(byte[] tmp, int width)

    {

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

      {

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

      }

    return false;

    }

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

  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( containsBlackness(tmp,width) ) 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( containsBlackness(tmp,width) ) return i;

      }

    return width-1;

    }

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

// 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 wBytes = 4*width;

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

    output.order(ByteOrder.LITTLE_ENDIAN);

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

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

    int startRow = (firstRow+lastRow+width)/2;

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

      {

      input.position((startRow-i)*wBytes);

      input.get(tmp);

      output.position(i*wBytes);

      output.put(tmp);

      }

    output.rewind();

    return output;

    }

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

  private void replaceColor(byte[] tmp, int index, int numColors)

    {

    byte A = (byte)0xab;

    int CUTOFF = 100;

    switch(numColors)

      {

      case 4: if( tmp[index+1]==0 ) { tmp[index]=A; tmp[index+1]=0; tmp[index+2]=0; }

              else

                {

                if( tmp[index]==tmp[index+1] )

                  {

                  if( tmp[index]<0 || tmp[index]>CUTOFF )  { tmp[index]=A; tmp[index+1]=A; tmp[index+2]=0; }

                  }

                else { tmp[index]=0; tmp[index+1]=0; tmp[index+2]=A; }

                }

              break;

      case 6: if( tmp[index+2]!=0 )

                {

                if( tmp[index]==0 ) { tmp[index]=0; tmp[index+1]=0; tmp[index+2]=A; }

                }

              else

                {

                if( tmp[index]==tmp[index+1] ) { tmp[index]=A; tmp[index+1]=A; tmp[index+2]=0; }

                else { tmp[index]=A; tmp[index+1]=0; tmp[index+2]=0; }

                }

              break;

      case 8: if( tmp[index+2]!=0 )

                {

                if( tmp[index+1]==0 ) { tmp[index]=A; tmp[index+1]=0; tmp[index+2]=0; }

                }

              else

                {

                if( tmp[index+1]==0 ) { tmp[index]=0; tmp[index+1]=0; tmp[index+2]=A; }

                else

                  {

                  if( tmp[index]==tmp[index+1] ) { tmp[index]=A; tmp[index+1]=A; tmp[index+2]=0; }

                  else { tmp[index]=0; tmp[index+1]=A; tmp[index+2]=0; }

                  }

                }

              break;

      case 12:if( tmp[index+2]==0 )

                {

                if( tmp[index+1]==0 )  {tmp[index]=A; tmp[index+1]=0; tmp[index+2]=0;}

                else  {tmp[index]=0; tmp[index+1]=A; tmp[index+2]=0;}

                }

              else

                {

                if( tmp[index]==tmp[index+1] )

                  {

                  if( tmp[index]<0 || tmp[index]>CUTOFF ) {tmp[index]=A; tmp[index+1]=A; tmp[index+2]=0;}

                  }

                else  {tmp[index]=0; tmp[index+1]=0; tmp[index+2]=A;}

                }

              break;

      }

    }

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

  private ByteBuffer replaceColors(ByteBuffer input, byte[] tmp, int size, int numColors)

    {

    int marker = (int)(255*BandagedCreatorRenderer.BRIGHTNESS);

    int wBytes = 4*size;

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

    output.order(ByteOrder.LITTLE_ENDIAN);

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

      {

      input.position(i*wBytes);

      input.get(tmp);

      for(int j=0; j<size; j++)

        {

        if( tmp[4*j]==marker && tmp[4*j+1]==marker && tmp[4*j+2]==marker )

          {

          tmp[4*j  ]=0;

          tmp[4*j+1]=0;

          tmp[4*j+2]=0;

          tmp[4*j+3]=0;

          }

        else if( tmp[4*j]!=0 || tmp[4*j+1]!=0 || tmp[4*j+2]!=0 ) replaceColor(tmp,4*j,numColors);

        }

      output.position(i*wBytes);

      output.put(tmp);

      }

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

   // ByteBuffer bufTransp = replaceColors(bufSquare,tmp,width,load.numColors);

    final String filename = load.filename;

    BufferedOutputStream bos =null;

    final Activity act = mWeakAct.get();

    try

      {

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

      Bitmap bmp = Bitmap.createBitmap( width, width, 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 io) {}

        }

      }

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

    }

  }