yousician

Actually impressed by an app, yousician, it actually looks good, I always wanted to learn to play then becoming an adult all the teachers only want to teach dam kids. Never mind :).

Pleased with the lego app, I got some more tests running and talking to people about should tests be run only the public methods or the private ones using reflection.

 

Books and colours

Book I've been reading, Icarus deception by Seth Godin, enjoyed it, about making art is not comfortable and makes us feel vulnerable which is how you know you're making something new. I did like that Icarus could also fly too low.

Article I found interesting, Crash only software.
Sit stand desk, stand desks are normally so expensive but this looks good for the cost, varidesk.
12 years in software development article. 

Been playing with a Lego picture maker and trying to get rgb values from Lego colours, after doing an average of the rgb values and using the closest average made a lot of thing purple. Delta-E 1976, fast enough with results accurate enough for what I want. My implementation, more info on it.

public static int[] getLegoColourEquiv(int[] rgb) {
        int[] returnColourRGB = {1,1,1};
        if(rgb == null) {
            return returnColourRGB;
        }

        double lowestDelta = Double.MAX_VALUE;
        double deltaE;
        for (int[] colour : colours) {
            //DeltaE76 (CIE 1976)
            deltaE = Math.sqrt(
                    Math.pow(rgb[0] - colour[0], 2) +
                    Math.pow(rgb[1] - colour[1], 2) +
                    Math.pow(rgb[2] - colour[2], 2)
            );
            if(deltaE < lowestDelta) {
                lowestDelta = deltaE;
                returnColourRGB = Arrays.copyOf(colour,
                colour.length);
            }
        }

        return returnColourRGB;
    }

Update to lego thing as well

Link to MIT algorithms course, bought a book then omg this is hard.

Listening to podcasts https://codecombat.com/ came up, actually looks fun but bad memories of javascript under pressure.

I had another go at the lego picture maker, does seem to have a tendency to make the colours purple for some reason. Also IntStream just makes some of this stuff so easy.

Once it is in a better state I would like to get it on github. I get a bit hung up about poor code, I come back to it weeks later with wtf was I thinking. Need to add a front end, accept different input and output file types, and those actual lego nubs. 

Must get away from magic numbers. 

public static int[] getLegoColourEquiv(int[] rgb) {
    int[] returnColourRGB = {1,2,3};    
    if(rgb == null) {
        return returnColourRGB;
    }
    int rgbAverage = IntStream.of(rgb).sum() / rgb.length;
    int gapFromColour = Integer.MAX_VALUE;
    int colourAverage;
    int rgbDiff;

    for (int[] colour : colours) {
        colourAverage = IntStream.of(colour).sum() / colour.length;
        rgbDiff = rgbAverage - colourAverage ;
        if(rgbDiff < 0) { rgbDiff *= -1;}
        if(rgbDiff < gapFromColour) {
            gapFromColour = rgbDiff;
            returnColourRGB = Arrays.copyOf(colour, colour.length);
        }
    }
    return returnColourRGB;
}

Messy code which was fun to write

Some bits this week

cmd quser says when the user logged on, handy for when the boss asks why I am packing up so early, because I got here early :) 

Found what looks like a good book, The Icarus Deception: How High Will You Fly?

rainforestQA awesome to have that many testers on standby. 

Good pod cast, software engineering daily.

At the moment I like the idea of getting a laptop with a Linux on to play with even if it is dual boot.

So here is a mess but it works, trying to write a program that turns an image into lego blocks. 

 package com.company;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;
import java.io.File;
import java.io.IOException;

public class LegoPictureMaker {
    public String filePath;
    public BufferedImage img;
    public int legoSquareSideLength;

    public LegoPictureMaker(String filePath) {
        this.legoSquareSideLength = 16;
        this.filePath = filePath;
    }

    public void makeImage() {
        System.out.println("Grabbing file...");
        img = grabFile();
        System.out.println("Processing lego blocks");
        processFile();
        System.out.println("Done!");
    }

    //process file
    private void processFile() {

        //work out of squares needed in width and height
        int xTiles = img.getRaster().getWidth() / legoSquareSideLength;
        int yTiles = img.getRaster().getHeight() / legoSquareSideLength;

        //build image I can write to
        BufferedImage buildImage;
        buildImage = new BufferedImage(
                (xTiles * legoSquareSideLength),
                (yTiles * legoSquareSideLength),
                 BufferedImage.TYPE_INT_RGB);

        int totalTiles = xTiles * yTiles;
        int red= 0, green = 0, blue = 0;
        int[] testArray = new int[3];
        img.getRaster().getPixel(0,0, testArray);

        //make something usable
        WritableRaster writableRaster = (WritableRaster)buildImage.getData();
        int[][][] averageColour = new int[xTiles][yTiles][3];
        for(int x = 0; x < xTiles; x++) {
            for (int y = 0; y < yTiles; y++) {
                averageColour[x][y] = getAverageColour(x * legoSquareSideLength, y * legoSquareSideLength);
                writeTileColour(writableRaster, x * legoSquareSideLength, y * legoSquareSideLength, averageColour[x][y]);
            }
        }
        saveImage(buildImage, writableRaster);
    }

    private void writeTileColour(WritableRaster writableRaster, int xPoint, int yPoint, int[] rgbValues) {
        int endX = xPoint + legoSquareSideLength;
        int endY = yPoint + legoSquareSideLength;
        for (int x = xPoint; x < endX; x++) {
            for (int y = yPoint; y < endY; y++) {
                writableRaster.setPixel(x, y, rgbValues);
            }
        }
    }

    private int[] getAverageColour(int xPoint, int yPoint) {
        int red= 0, green = 0, blue = 0;
        int endX = xPoint + legoSquareSideLength;
        int endY = yPoint + legoSquareSideLength;
        int[] testArray = new int[3];;

        for (int i = xPoint; i < endX; i++) {
            for (int j = yPoint; j < endY; j++) {
                img.getRaster().getPixel(i,j, testArray);
                red += testArray[0];
                green += testArray[1];
                blue += testArray[2];
            }
        }
        int amountOfPixels = legoSquareSideLength * legoSquareSideLength;
        return new int[] {  red / amountOfPixels,
                            green / amountOfPixels,
                            blue / amountOfPixels};
    }

    //save image
    public void saveImage(BufferedImage buildImage, WritableRaster writableRaster) {
        //save and close file
        buildImage.setData(writableRaster);
        File outputFile = new File("testest.png");
        try {
            ImageIO.write(buildImage, "png", outputFile);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    //get the file
    public BufferedImage grabFile() {
        BufferedImage img = null;

        if (filePath != null && !filePath.isEmpty()) {
            try {
                img = ImageIO.read(new File(this.filePath));
            } catch (IOException ex) {
                System.out.println("broke here");
                ex.printStackTrace();
            }
        }
        return img;
    }
}

Challenge where I got stuck

Annoyed something so simple took this long and still doesn't bloody work correctly, waaah!

 package com.company;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class PasswordGame {
    public String[] guessWords;
    public String password;
    enum difficultySettings {VERY_EASY, EASY, MEDIUM, HARD, VERY_HARD}
    difficultySettings difficulty;
    public int amountOfGuesses;

    public PasswordGame(difficultySettings aDifficulty) {
        this.difficulty = aDifficulty;
        getGuessWordsAndPassword(difficulty);
    }

    public void gameRun() {
        System.out.println("You have " + amountOfGuesses + " guess");
        System.out.println("Your word list: ");
        printWordList();
        boolean gameWon = false;
        String wordGuess;
        System.out.println("Password is: " + this.password);
        while (!gameWon && amountOfGuesses > 0) {
            wordGuess = getGuess();
            if (wordGuess.equals(password)) {
                gameWon = true;
            } else {
                amountOfGuesses--;
                System.out.println("Unlucky: " + passwordCompare(wordGuess) + " guesses left: " + amountOfGuesses);
            }
        }

        if (gameWon) {
            System.out.println("You WIN!!!");
        } else {
            System.out.println("You lose :(");
        }
    }

    private String passwordCompare(String wordGuess) {
        int correctChar = 0;
        int correctCharAndPlace = 0;
        ArrayList<Character> passWordCopy = new ArrayList<>();
        for (char aChar : password.toCharArray()) { passWordCopy.add(aChar); }
        ArrayList<Character> guess = new ArrayList<>();
        for (char aChar : wordGuess.toUpperCase().toCharArray()) { guess.add(aChar); }

        for(int i = 0; i < guess.size() && i < passWordCopy.size(); i++) {
            if (guess.get(i) == passWordCopy.get(i)) {
                correctChar++; correctCharAndPlace++;
            } else if ( passWordCopy.contains(guess.get(i))) {
                correctChar++;
                passWordCopy.set(i, '+');
            }
        }


        return "correct chracter: " + correctChar + " and in the correct place: " + correctCharAndPlace;
    }

    private String getGuess() {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String wordGuessed = "";
        try {
            wordGuessed = reader.readLine();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return wordGuessed;
    }

    private void printWordList() {
        for (String word : guessWords) {
            System.out.println(word);
        }
    }

    public String[] getGuessWordsAndPassword(difficultySettings aDifficulty) {
        switch (aDifficulty) {
            case VERY_EASY:
                amountOfGuesses = 20;
                populateWordsAndPassWord(10,5);
                break;
            case EASY:
                amountOfGuesses = 15;
                populateWordsAndPassWord(10,6);
                break;
            case MEDIUM:
                amountOfGuesses = 12;
                populateWordsAndPassWord(10,7);
                break;
            case HARD:
                amountOfGuesses = 10;
                populateWordsAndPassWord(10,8);
                break;
            case VERY_HARD:
            default:
                amountOfGuesses = 8;
                populateWordsAndPassWord(10,9);
                break;
        }

        return new String[]{};
    }

    private void populateWordsAndPassWord(int wordLength, int amountOfWords) {
        ArrayList<String> filteredList = this.filteredWordList(wordLength, amountOfWords);
        Collections.shuffle(filteredList);
        this.guessWords = filteredList.toArray(new String[filteredList.size()]);
        this.password = guessWords[new Random().nextInt(this.guessWords.length)];
    }

    private ArrayList<String> filteredWordList(int wordLength, int amountOfwords) {
        FileReader fileReader;
        BufferedReader bufferedReader;
        Set<String> wordSet = new HashSet<>(); //set to filter duplicates
        try {
            fileReader = new FileReader("someplace\\enable1.txt");
            bufferedReader = new BufferedReader(fileReader);
            String word;
            while ((word = bufferedReader.readLine()) != null) {
                if(word.length() == wordLength) {
                    wordSet.add(word);
                }
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        ArrayList<String> words = new ArrayList<>(wordSet);
        ArrayList<String> sizedWords = new ArrayList<>();

        for (int i = 0; i < amountOfwords; i++) {
            sizedWords.add(words.get(i).toUpperCase());
        }
        return sizedWords;
    }
}

Short one

I went over board on an intermediate challenge so put off doing a post. 

Links for much happiness,

http://12factor.net/
http://www.sunjw.us/jstoolnpp/ js tool, good plugin for notepad++
https://skillsmatter.com/ guys at work talking about clojure came across skills matter, over £2k to listen to uncle bob!

Got quite into evernote, beats the bits of paper I always lose by a large margin. 

Since I am studying for the Java 8 OCA, http://enthuware.com/index.php apparently is the thing to do, the exam does seem quite pedantic to me but that also shows how dependent I am on autocomplete.

Windows 10 start button not working and I also did a programming challenge

On windows 10 and needed some anti virus, installed Kaspersky, windows key no longer works and cannot click on any of the buttons except shortcuts. I may need another way of getting to applications other than win key and type.

Solution: https://www.techmesto.com/fix-start-menu-broken-windows-10-technical-preview/ 

Or run this in power shell

Get-AppXPackage -AllUsers | Foreach {Add-AppxPackage 

-DisableDevelopmentMode 

-Register "$($_.InstallLocation)\AppXManifest.xml"}

Challenge 238 Easy consonants and vowels

package com.company;
import java.util.Random;
import java.util.regex.*;

public class Main {
    public static void main(String[] args) {
       String inputString = "CVcvcvcc";
        char[] consonants = "bcdfghjklmnpqrstvwxyz".toCharArray();
        char[] vowels = "aeiou".toCharArray();
        Random random = new Random();
        Pattern pattern = Pattern.compile("[^vcVC]");
        Matcher matcher = pattern.matcher(inputString);

        if (matcher.find()) {
            System.out.println("Invalid character in input");
        } else {
            StringBuilder output =  

            new StringBuilder(inputString.length());
            for (char letter : inputString.toCharArray()) {
                switch (letter) {
                    case 'c':
                      output.append(consonants[random.nextInt

                      (consonants.length)]);
                      break;
                    case 'C':
                      output.append(Character.toUpperCase 

                      (consonants[random.nextInt(consonants.length)]));
                      break;
                    case 'V':
                      output.append(Character.toUpperCase 

                      (vowels[random.nextInt(vowels.length)]));
                      break;
                    case 'v':
                      output.append(vowels[random.nextInt

                      (vowels.length)]);
                      break;
                }
            }
            System.out.println(output);
        }
    }
}

Originally did this with multiple ifs' and it looked bloody awful.