ゆっちのBlog

Java

お正月なのでぷるんぷるんやってみた

Java

新年あけましておめでとうございます。

本年もどうぞよろしくお願いします。

さて、2016年になったからって私が私であることにはかわりない。

いつものようにふざけて楽しんでいけたらそれだけで幸せです。

ということで、今年もおっぱいネタでスタートです。

いつからかは覚えてないけど12月は Advent Calendar ってのがあって忙しい中１日から25日までリレー方式である特定のカテゴリーのブログをかくイベントがあります。

その中で JavaFX Advent Calendar 2015 ってのがあって私にとっては知らない技術を知るいい機会となっています。

今日のおっぱいネタはその中の一つの技術を使えば男の浪漫（女性からみたら単なる馬鹿）を満たせると思いチャレンジした記録です。

おもいっきりふざけた内容ですのでご容赦くださいませ。

では、どんな技術を使おうとしているかは元ネタのエントリーを読んでください。

とても丁寧に解説されています。

JavaFX in the Box　Displacement Map

この DisplacementMap と FloatMap クラスが鍵となるようです。

これって聞いたこともみたこともないなぁ・・

DisplacementMap はエフェクトの紹介でちらっと名前だけは見たことあるけどこれを使ってこんなことができるよってのは記憶にない。

JavaDoc にはテキストを変形させるサンプルコードの断片がありますね。

そんなことやっても面白くないよ。

そこでネタ元でもレンズ効果を試していたけど時間切れで手抜きによる不本意な結果となってます。

時間があれば再チャレンジすると書いてあったのでゆっくり待ちましょう。(^_^)

それでも男の浪漫達成にはレンズ効果は必須なので数学力の乏しい私は適当にあーでもない、こうでもない、と本当にいい加減に進めます。

理想とするカーブを得る関数を作れる人生を送りたかった。(>_<｡)

とりあえず、レンズ効果を得るためにプログラムを組んでみた。

と言ってもネタ元のコードをほとんど美味しくいただいてます。

package jp.yucchi.trydisplacementmap;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.effect.DisplacementMap;
import javafx.scene.effect.Effect;
import javafx.scene.effect.FloatMap;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.input.MouseButton;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

/**
 *
 * @author Yucchi
 */
public class TryDisplacementMap extends Application {
    
    private static final int RADIUS = 180;
    private int width;
    private int height;
    private int centerX;
    private int centerY;
    private int offsetX;
    private int offsetY;
    
    @Override
    public void start(Stage primaryStage) {
       
        StackPane root = new StackPane();
        root.setPrefSize(419, 594);
        ImageView iv = new ImageView(new Image(getClass().getResource("resources/g1.jpg").toString()));
        
        width = (int) iv.getImage().getWidth();
        height = (int) iv.getImage().getHeight();
        centerX = width / 2;
        centerY = height / 2;
        
        root.getChildren().add(iv);
        Scene scene = new Scene(root);
        primaryStage.setScene(scene);
        primaryStage.setTitle("DisplacementMap で遊ぶ！");
        primaryStage.show();
        
        iv.setOnMouseClicked(e -> {
            if (e.getButton() == MouseButton.PRIMARY) {
                offsetX = (int) (e.getX() - centerX);
                offsetY = (int) (e.getY() - centerY);
            iv.setEffect(createEffect(width, height));}
        });

    }

    private Effect createEffect(int width, int height) {

        FloatMap floatMap = new FloatMap(width, height);
        
        int moveY = 0; // 50, -50

        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                double r = Math.sqrt(Math.pow(x - centerX - offsetX, 2.0d) + Math.pow(y - centerY - offsetY + moveY, 2.0d));
                if (r <= RADIUS && r != 0) {
                    float v = (float) (Math.sin(Math.PI * y / height * 2.0) * 0.10f * Math.pow((RADIUS - r) / RADIUS, 0.7));
                    float u = (float) (Math.sin(Math.PI * x / width * 2.0) * 0.10f * Math.pow((RADIUS - r) / RADIUS, 0.7));
                    floatMap.setSamples(x, y, u, v);
                } 
            }
        }
        
        DisplacementMap displacementMap = new DisplacementMap(floatMap);
        return displacementMap;

    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        launch(args);
    }
    
}

package jp.yucchi.trydisplacementmap;

import javafx.application.Application;

import javafx.scene.Scene;

import javafx.scene.effect.DisplacementMap;

import javafx.scene.effect.Effect;

import javafx.scene.effect.FloatMap;

import javafx.scene.image.Image;

import javafx.scene.image.ImageView;

import javafx.scene.input.MouseButton;

import javafx.scene.layout.StackPane;

import javafx.stage.Stage;

/**

* @author Yucchi

public class TryDisplacementMap extends Application {

private static final int RADIUS = 180;

private int width;

private int height;

private int centerX;

private int centerY;

private int offsetX;

private int offsetY;

@Override

public void start(Stage primaryStage) {

StackPane root = new StackPane();

root.setPrefSize(419, 594);

ImageView iv = new ImageView(new Image(getClass().getResource("resources/g1.jpg").toString()));

width = (int) iv.getImage().getWidth();

height = (int) iv.getImage().getHeight();

centerX = width / 2;

centerY = height / 2;

root.getChildren().add(iv);

Scene scene = new Scene(root);

primaryStage.setScene(scene);

primaryStage.setTitle("DisplacementMap で遊ぶ！");

primaryStage.show();

iv.setOnMouseClicked(e -> {

if (e.getButton() == MouseButton.PRIMARY) {

offsetX = (int) (e.getX() - centerX);

offsetY = (int) (e.getY() - centerY);

iv.setEffect(createEffect(width, height));}

});

}

private Effect createEffect(int width, int height) {

FloatMap floatMap = new FloatMap(width, height);

int moveY = 0; // 50, -50

for (int x = 0; x < width; x++) {

for (int y = 0; y < height; y++) {

double r = Math.sqrt(Math.pow(x - centerX - offsetX, 2.0d) + Math.pow(y - centerY - offsetY + moveY, 2.0d));

if (r <= RADIUS && r != 0) {

float v = (float) (Math.sin(Math.PI * y / height * 2.0) * 0.10f * Math.pow((RADIUS - r) / RADIUS, 0.7));

float u = (float) (Math.sin(Math.PI * x / width * 2.0) * 0.10f * Math.pow((RADIUS - r) / RADIUS, 0.7));

floatMap.setSamples(x, y, u, v);

}

DisplacementMap displacementMap = new DisplacementMap(floatMap);

return displacementMap;

}

/**

* @param args the command line arguments

public static void main(String[] args) {

launch(args);

}

これを実行するとこうなります。

エフェクトをかける前の画像です。

エフェクトをかけた画像です。

中央が盛り上がって少しはレンズ効果が出ているようです。

ただ、境界がもっとスムースになるようにしたいですね。

このエフェクトを使えば貧乳を救えるかもしれない。 |:ﾟ●=(ﾟｪﾟ｀)o ｸﾞﾁｬ

ちょっと FloatMap の計算過程で Y 軸の値を変更してみました。

解りにくいかも知れませんが歪みながら上下に移動しています。

これを上手く利用できれば浪漫に一歩近づくことができるかもしれない。

とりあえず、先ほどのプログラムをクリックした位置を中心にレンズ効果を得られるように変更してみました。

すみません。もう変更ずみでした。

元画像です。

レンズエフェクトを適用した結果画像です。

ううっ

やはりちゃんとしたカーブを得る関数でプログラムを動かしてないので厳しいですね。

ちなみにタレントの堀北真希さんの画像を使ってレンズ効果を試したらあちこちから怒られてしまったので今回はファンのいない一般人の少女に頑張ってもらいました。

だけどくじけてはいけない！

先ほどのレンズ効果でも目的は達成できるかもしれない。いや、できると信じよう！

おっぱい星人である私はがんばりました。

そこそこ楽しめるプログラムができました。

このプログラムのソースコードを載せようと思ったけど長くなる割に前述のプログラムをアニメーションタイマーで動かしただけのようなものなので止めときます。

レンズ効果の部分の数値はちょっと変更してあります。

重要なことを忘れてました。年末の忙しい時にこんな~~楽しい~~ふざけたプログラムを組んでると家族から冷ややかな視線をあびることになります。

男の浪漫は常に危険と隣り合わせってことです！

年越しプログラミングで作った新年早々のプログラム、まだまだだけどネタ的には満足だ！(^_^)

Java 最高！

Hatena タグ: Java

TAGS: Java | 2016年1月1日5:15 AM | Comment : 0

よく見かけるネタ IntegerCache 問題

Java

昔からよくある Java パズルでブログの更新を久しぶりにしておきます。

次のコードの結果はどうなるでしょう？

package jp.yucchi.integercachedemo;

public class IntegerCacheDemo {

    public static void main(String[] args) {
        
        Integer i = 127;     
        Integer j = 127;
         
        System.out.println(i == j);
        
        Integer k = 128;
        Integer l = 128;
        
        System.out.println(k == l);
        
        Integer m = -128;     
        Integer n = -128;
         
        System.out.println(m == n);
        
        Integer o = -129;
        Integer p = -129;
        
        System.out.println(o == p);

    }
    
}

package jp.yucchi.integercachedemo;

public class IntegerCacheDemo {

public static void main(String[] args) {

Integer i = 127;

Integer j = 127;

System.out.println(i == j);

Integer k = 128;

Integer l = 128;

System.out.println(k == l);

Integer m = -128;

Integer n = -128;

System.out.println(m == n);

Integer o = -129;

Integer p = -129;

System.out.println(o == p);

}

true
false
true
false

となります。

間違えてませんよね！

今さらですが、これらは Integer.valueOf() メソッドが使われて -128 から 127 までは IntegerCache クラスであらかじめ用意されているものが使われる。

小さな親切、大きなお世話というやつです！

でも、用意してある物は使わなくては損ですよね。

じゃあ、どうしてもっといっぱい作って用意しておいてくれないの？って言うあなたに

JVM の実行時引数による制御も可能です。

-Djava.lang.Integer.IntegerCache.high=<size>

それとも、

-XX:AutoBoxCacheMax=<size>

で OK です。

-Djava.lang.Integer.IntegerCache.high=128 と設定して実行すると先ほどのプログラムの結果は

true
true
true
false

となります。

ちなみに IntegerCache の最小値の設定方法は私は知りません。(;゜ロ゜)

以上、よくあるネタ終了です。

Hatena タグ: Java

TAGS: Java | 2015年12月8日4:47 PM | Comment : 0

Java 8 時代の ConcurrentHashMap で遊んでみた。

Java

またまた Blog の更新をさぼっています。

と言うことで適当なエントリーを書いてみます。

ConcurrentHashMap

J2SE5.0 で java.util.concurrent に ConcurrentHashMap が導入されました。

ConcurrentHashMap は容易に安全に並行処理を実現するために作られました。

Collections.synchronizedMap ってのもあるのですが、それは使い方が微妙で詳しい説明は省略しますが Iterator などの反復処理で ConcurrentModificationException をスローすることがあります。

Collections.synchronizedMap は、Map のロックを取得すると他のスレッドからアクセスを禁じられます。

ConcurrentHashMap だと、Iterator および Enumeration は、ある時点または反復子/列挙の作成以降のハッシュテーブルの状態を反映する要素を返すように設計されているため、

ConcurrentModificationException をスローすることはありません。

しかし、一度に 1 つのスレッドだけしか反復子を使用できません。

あと、HashMap はエントリーのキーや値にnullを使用できますが、ConcurrentHashMapでは使用できません。

NullPointerException が投げられます。

ConcurrentHashMap は、HashMap のようなハッシュを使った Map ですがロックストライピングと言われる粒度の小さなロック方式を採用しています。

つまり、Map 全体をロックして排他アクセスする必要がなければ ConcurrentHashMap は、とても魅力的な存在となります。

しかし、J2SE5.0 の時には、ConcurrentHashMap を便利に使うにはまだまだパーツが揃っていませんでした。

便利に使えそうだったのはアトミックに実行される下記メソッドくらいでした。

public V putIfAbsent(K key, V value)

public boolean remove(Object key, Object value)

public V replace(K key, V value)

public boolean replace(K key, V oldValue, V newValue)

また古い J2SE5.0 ネタかと思わせて、ここから最新の Java SE 8 ネタです。

Java SE 8 で ConcurrentHashMap に追加された便利な機能をいくつか試してみます。

はじめに、ConcurrentHashMap というネーミングから何をやってもスレッドセーフだと思い込んでしまうと泣きます。

例えば、下記プログラムのように複数スレッドから ConcurrentHashMap の値の更新があるとします。

最終的に Key “HOGE”, Value は 80 となることを期待しますが残念なことになります。

package jp.yucchi.concurrenthashmapexample0;

import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Yucchi
 */
class Counter {

    ConcurrentHashMap<String, Integer> map;
    private Random random = new Random();

    public Counter(ConcurrentHashMap<String, Integer> map) {
        this.map = map;
    }

    void incrementCounter() {
        for (int i = 0; i < 10; i++) {
            try {
                TimeUnit.MILLISECONDS.sleep(random.nextInt(50));
            } catch (InterruptedException ex) {
                Logger.getLogger(Counter.class.getName()).log(Level.SEVERE, null, ex);
            }
            int counter = map.get("HOGE");
            map.put("HOGE", ++counter);
        }
        System.out.println(Thread.currentThread().getName() + ": HOGE, " + map.get("HOGE"));
    }

}

package jp.yucchi.concurrenthashmapexample0;

import java.util.Random;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.TimeUnit;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

* @author Yucchi

class Counter {

ConcurrentHashMap<String, Integer> map;

private Random random = new Random();

public Counter(ConcurrentHashMap<String, Integer> map) {

this.map = map;

}

void incrementCounter() {

for (int i = 0; i < 10; i++) {

try {

TimeUnit.MILLISECONDS.sleep(random.nextInt(50));

} catch (InterruptedException ex) {

Logger.getLogger(Counter.class.getName()).log(Level.SEVERE, null, ex);

}

int counter = map.get("HOGE");

map.put("HOGE", ++counter);

}

System.out.println(Thread.currentThread().getName() + ": HOGE, " + map.get("HOGE"));

}

package jp.yucchi.concurrenthashmapexample0;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;

/**
 *
 * @author Yucchi
 */
public class ConcurrentHashMapExample0 {

    public static void main(String[] args) {

        ConcurrentHashMap<String, Integer> count = new ConcurrentHashMap<>();
        count.put("HOGE", 0);

        Counter counter = new Counter(count);

        CompletableFuture<Void> cnt_1 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_2 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_3 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_4 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_5 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_6 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_7 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_8 = CompletableFuture.runAsync(() -> counter.incrementCounter());

        CompletableFuture<Void> allTask = CompletableFuture.allOf(cnt_1, cnt_2, cnt_3, cnt_4, cnt_5, cnt_6, cnt_7, cnt_8);
        allTask.join();

        if (allTask.isDone()) {
            count.forEach(1, (key, value) -> {
                System.out.println(Thread.currentThread().getName() + " : " + key + ", " + value);
            });
        }
    }

}

package jp.yucchi.concurrenthashmapexample0;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.ConcurrentHashMap;

/**

* @author Yucchi

public class ConcurrentHashMapExample0 {

public static void main(String[] args) {

ConcurrentHashMap<String, Integer> count = new ConcurrentHashMap<>();

count.put("HOGE", 0);

Counter counter = new Counter(count);

CompletableFuture<Void> cnt_1 = CompletableFuture.runAsync(() -> counter.incrementCounter());

CompletableFuture<Void> cnt_2 = CompletableFuture.runAsync(() -> counter.incrementCounter());

CompletableFuture<Void> cnt_3 = CompletableFuture.runAsync(() -> counter.incrementCounter());

CompletableFuture<Void> cnt_4 = CompletableFuture.runAsync(() -> counter.incrementCounter());

CompletableFuture<Void> cnt_5 = CompletableFuture.runAsync(() -> counter.incrementCounter());

CompletableFuture<Void> cnt_6 = CompletableFuture.runAsync(() -> counter.incrementCounter());

CompletableFuture<Void> cnt_7 = CompletableFuture.runAsync(() -> counter.incrementCounter());

CompletableFuture<Void> cnt_8 = CompletableFuture.runAsync(() -> counter.incrementCounter());

CompletableFuture<Void> allTask = CompletableFuture.allOf(cnt_1, cnt_2, cnt_3, cnt_4, cnt_5, cnt_6, cnt_7, cnt_8);

allTask.join();

if (allTask.isDone()) {

count.forEach(1, (key, value) -> {

System.out.println(Thread.currentThread().getName() + " : " + key + ", " + value);

});

}

このプログラムの実行結果は次のようになります。

ForkJoinPool.commonPool-worker-18: HOGE, 48
ForkJoinPool.commonPool-worker-29: HOGE, 58
ForkJoinPool.commonPool-worker-8: HOGE, 65
ForkJoinPool.commonPool-worker-4: HOGE, 67
ForkJoinPool.commonPool-worker-11: HOGE, 68
ForkJoinPool.commonPool-worker-15: HOGE, 70
ForkJoinPool.commonPool-worker-25: HOGE, 73
ForkJoinPool.commonPool-worker-22: HOGE, 75
main : HOGE, 75

更新処理まではスレッドセーフでないということですね。

それではどのように対処すればいいでしょうか？

java.util.concurrent.atomic.LongAdder を使ってみます。

LongAdder クラスは、プリミティブ型に対するアトミック操作を行うため Java SE 8 から追加されたクラスです。

LongAdder クラスには、add(1)と等価な increment() メソッドと、add(-1)と等価な decrement() メソッドがあります。

LongAdder クラスを使って修正したプログラムは下記のようになります。

package jp.yucchi.concurrenthashmapexample1;

import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.LongAdder;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Yucchi
 */
class Counter {

    ConcurrentHashMap<String, LongAdder> map;
    private Random random = new Random();

    public Counter(ConcurrentHashMap<String, LongAdder> map) {
        this.map = map;
    }

    void incrementCounter() {
        for (int i = 0; i < 10; i++) {
            try {
                TimeUnit.MILLISECONDS.sleep(random.nextInt(50));
            } catch (InterruptedException ex) {
                Logger.getLogger(Counter.class.getName()).log(Level.SEVERE, null, ex);
            }
            map.get("HOGE").increment();
        }
        System.out.println(Thread.currentThread().getName() + ": HOGE, " + map.get("HOGE"));
    }

}

package jp.yucchi.concurrenthashmapexample1;

import java.util.Random;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.LongAdder;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

* @author Yucchi

class Counter {

ConcurrentHashMap<String, LongAdder> map;

private Random random = new Random();

public Counter(ConcurrentHashMap<String, LongAdder> map) {

this.map = map;

}

void incrementCounter() {

for (int i = 0; i < 10; i++) {

try {

TimeUnit.MILLISECONDS.sleep(random.nextInt(50));

} catch (InterruptedException ex) {

Logger.getLogger(Counter.class.getName()).log(Level.SEVERE, null, ex);

}

map.get("HOGE").increment();

}

System.out.println(Thread.currentThread().getName() + ": HOGE, " + map.get("HOGE"));

}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.LongAdder;

/**
 *
 * @author Yucchi
 */
public class ConcurrentHashMapExample1 {

    public static void main(String[] args) {

        ConcurrentHashMap<String, LongAdder> count = new ConcurrentHashMap<>();
        count.put("HOGE", new LongAdder());

        Counter counter = new Counter(count);

        CompletableFuture<Void> cnt_1 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_2 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_3 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_4 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_5 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_6 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_7 = CompletableFuture.runAsync(() -> counter.incrementCounter());
        CompletableFuture<Void> cnt_8 = CompletableFuture.runAsync(() -> counter.incrementCounter());

        CompletableFuture<Void> allTask = CompletableFuture.allOf(cnt_1, cnt_2, cnt_3, cnt_4, cnt_5, cnt_6, cnt_7, cnt_8);
        allTask.join();

        if (allTask.isDone()) {
            count.forEach(1, (key, value) -> {
                System.out.println(Thread.currentThread().getName() + " : " + key + ", " + value);
            });
        }
    }

}

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.atomic.LongAdder;

/**

* @author Yucchi

public class ConcurrentHashMapExample1 {

public static void main(String[] args) {

ConcurrentHashMap<String, LongAdder> count = new ConcurrentHashMap<>();

count.put("HOGE", new LongAdder());