tömb - címke - it-tanfolyam.hu

A Pi grafikus ábrázolása

2024. március 14. Szerző: Kaczur Sándor

A nemzetközi Pi nap alkalmából (március 14) Java programmal grafikusan ábrázoljuk a $π$ számjegyeit. Kiindulunk egy négyzet alakú grafikus felület középpontjából. Ezt tekintjük origónak. Sorra vesszük a $π$ első néhány számjegyét: 100, 1000, 10000 paraméterezhető módon. Minden számjegyet egy rövid szakasszal ábrázolunk. A szakaszok egymást követik. Az előző végpontja megegyezik a következő kezdőpontjával. A rajzolás elejét és végét kör jelzi.

Tervezés

Az alábbi szabály alapján döntjük el, hogy a $π$ előforduló számjegyei esetén melyik irányba és milyen színnel rajzolunk szakaszt:

A $π$ első 100000 db számjegyét tároljuk egy szövegfájlban. Ömlesztve, sortörés, tizedesvessző nélkül. Így a $π$ első 30 számjegye: 314159265358979323846264338327. A szövegfájl helyét a String PI_FILE konstans jegyzi meg. A paraméternek megfelelően ebből vesszük az első N db számjegyet. Ezt a Java program beolvassa egy String típusú pi szövegobjektumba. A számjegyek összetartozó adatait egy Digit osztály rendeli egymáshoz. Ennek három adattagja van: melyik számjegy: int digit, melyik irányba kell szakaszt rajzolni java.awt.Point direction, milyen színnel kell szakaszt rajzolni java.awt.Color color. A tízféle színt egy konstans tömb tárolja: Color[] COLORS.

Részletek a Java forráskódból

A $π$ tízféle számjegyéből az alábbi forráskód-részlettel létrejön egy tömb adatszerkezet: Digit[] digits. A koordináták/vektorok kiszámítása követi az analóg óra számlapjának 36 fokonként való felosztását.

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

Point p=new Point(

(int)(Math.cos(Math.toRadians(i*36-90))*LINE_LENGTH),

(int)(-Math.sin(Math.toRadians(i*36-90))*LINE_LENGTH)

);

digits[i]=new Digit(i, p, COLORS[i]);

}

A rajzoláshoz szükséges még néhány konstans: milyen vastag vonalat kell rajzolni: double PEN_RADIUS, mekkora átmérőjű kör jelzi a rajzolás kezdő- és végpontját: double POINT_RADIUS, milyen hosszú vonalat kell rajzolni: int LINE_LENGTH, a rajzterületet mekkorára kell méretezni/skálázni: int SCALE.

Mindezek alapján az alábbi forráskód-részlet vizualizálja a $π$ számjegyeit:

private void piDraw() {

StdDraw.setScale(-SCALE, SCALE);

StdDraw.setPenRadius(PEN_RADIUS);

Point p1=new Point(0, 0);

StdDraw.setPenColor(digits[3-1].getColor());

StdDraw.circle(p1.x, p1.y, POINT_RADIUS);

for(int i=0; i<PI.length(); i++) {

int digit=Integer.parseInt(""+PI.charAt(i));

Point p2=new Point(

p1.x+digits[digit].getDirection().x,

p1.y+digits[digit].getDirection().y);

StdDraw.setPenColor(digits[digit].getColor());

StdDraw.line(p1.x, p1.y, p2.x, p2.y);

p1=p2;

}

StdDraw.circle(p1.x, p1.y, POINT_RADIUS);

}

Eredmény

Eredményül ezek az ábrák készíthetők el:

A rajzoláshoz felhasználtuk az StdDraw osztályt, amely ennek a tankönyvnek a példatárából származik: Robert Sedgewick, Kevin Wayne: Computer Science: An Interdisciplinary Approach, 1st edition, Princeton University, Addison-Wesley Professional, 2016, ISBN 978-0134076423. Az osztály metódusaival könnyen beállítható a nézőpont, a vízszintes/függőleges skála, a rajzoláshoz használt toll mérete/színe és a grafikai primitívek közül csak a kör és szakasz ábrázolása szükséges.

Korábban is megemlékeztünk néhány közelítő algoritmus – Viète-féle sor, Leibniz-féle sor, Wallis-formula, Csebisev-sor – implementálásával erről az ünnepnapról: Nemzetközi Pi nap. Ajánljuk korábbi blog bejegyzéseinket rajzolás, animáció, grafika címkékkel, illetve ASCII művészet Java-ban.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek, 13-16. óra: Tömbök, 17-28. óra: Objektumorientált programozás, 29-36. óra: Grafikus felhasználói felület, 37-44. óra: Fájlkezelés alkalmaihoz kötődik.

Szívgörbe ábrázolása

2024. február 14. Szerző: Kiss Balázs

Szívgörbét ábrázolunk Java programmal. A Valentin-nap inspirálta ezt a feladatot. Számos matematikai görbe ismert, amelyek szívformához (kardioid) hasonlítanak. Szükséges egy megfelelő paraméteres görbe. A függvény szív formájú ábrája/grafikonja és egyenletrendszere alapján is nagy a választék.

Ábrázoljuk ezt a paraméteres szívgörbét Java swing GUI felületen!

A szívgörbe ábrázolásához felhasználom az StdDraw osztályt, amely ennek a tankönyvnek a példatárából származik: Robert Sedgewick, Kevin Wayne: Computer Science: An Interdisciplinary Approach, 1st edition, Princeton University, Addison-Wesley Professional, 2016, ISBN 978-0134076423. Az osztály metódusaival könnyen beállítható a nézőpont, a vízszintes/függőleges skála, a rajzoláshoz használt toll mérete/színe és a grafikai primitívek közül csak a pont ábrázolása szükséges.

Négy megoldást mutatok. Mindegyik azonos szívgörbét rajzol a fenti egyenletrendszer alapján. Mindegyik metódus átveszi az N paramétert, amely az összetartozó x és y koordinátapárok számát jelenti. Az N db pont meghatározása/kiszámolása szükséges a szívgörbe ábrázolásához. A szívgörbe ábrázolása önálló ablakban – grafikus felhasználói felületen – jelenik meg. A feladat matematikai jellegéből adódik, hogy tipikus a t nevű ciklusváltozó használata. A metódusokat a vezérlés az 512 paraméterrel hívja meg.

1. megoldás

static void heartCurveDraw1(final int N) {

double[] x=new double[N];

double[] y=new double[N];

for(int t=0; t<N; t++) {

x[t]=Math.sqrt(2)*Math.pow(Math.sin(t), 3);

y[t]=-Math.pow(Math.cos(t), 3)-Math.pow(Math.cos(t), 2)+

2*Math.cos(t);

}

for(int t=0; t<N; t++)

StdDraw.point(x[t], y[t]);

}

A heartCurveDraw1() metódus a kiszámolt x és y koordinátákat két párhuzamos, double típusú tömb adatszerkezetben tárolja. A két tömbbe összesen 2*N db double típusú szám kerül. Azonos index jelöli az összetartozó koordinátapárokat. Az egymást követő két ciklus közül az első előállítja az adatszerkezetet és a második megjeleníti a pontokat.

2. megoldás

static void heartCurveDraw2(final int N) {

Point2D[] point=new Point2D[N];

for(int t=0; t<N; t++)

point[t]=new Point2D.Double(

Math.sqrt(2)*Math.pow(Math.sin(t), 3),

-Math.pow(Math.cos(t), 3)-Math.pow(Math.cos(t), 2)+

2*Math.cos(t));

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

StdDraw.point(point[i].getX(), point[i].getY());

}

A heartCurveDraw2() metódus a párhuzamos tömbök helyett adatszerkezetként egyetlen tömböt használ. A java.awt.geom csomag Point2D osztályú objektumai kerülnek a tömbbe. Mivel a Point2D absztrakt osztály, így a Double() osztálymetódusával (factory method) példányosítható úgy, hogy a szükséges koordinátapárokat megfelelően tudja tárolni. A tömbbe N db objektum kerül.

3. megoldás

static void heartCurveDraw3(final int N) {

for(int t=0; t<N; t++) {

Point2D p=new Point2D.Double(

Math.sqrt(2)*Math.pow(Math.sin(t), 3),

-Math.pow(Math.cos(t), 3)-Math.pow(Math.cos(t), 2)+

2*Math.cos(t));

StdDraw.point(p.getX(), p.getY());

}

A heartCurveDraw3() metódus nem használ tömb adatszerkezetet. Tehát nem emlékszik az összes pont koordinátájára. Ehelyett a ciklus röptében, egyesével létrehozza a pontobjektumokat és azonnal ki is rajzolja azokat (átmeneti az emlékezet).

4. megoldás

static void heartCurveDraw4(final int N) {

IntStream.range(0, N).

mapToObj(t -> new Point2D.Double(

Math.sqrt(2)*Math.pow(Math.sin(t), 3),

-Math.pow(Math.cos(t), 3)-Math.pow(Math.cos(t), 2)+

2*Math.cos(t))).

forEach(p -> StdDraw.point(p.getX(), p.getY()));

}

A heartCurveDraw4() metódus Stream API-t és lambda kifejezéseket használ. Az első N természetes számból készül egy sorozat, amihez röptében hozzákötődik a t-edik Point2D típusú objektum. Ezzel létrejön egy folyam adatszerkezet. Tehát van egy pillanat, amíg a program emlékszik az összes folyambeli pontobjektumra. Végül a folyam feldolgozása, bejárása során egyesével megszólítva a folyam objektumait, a pontok kirajzolódnak a vászonra.

A vezérlés

public static void main(String[] args) {

StdDraw.setPenRadius(0.01);

StdDraw.setPenColor(Color.RED);

StdDraw.setXscale(-Math.PI, Math.PI);

StdDraw.setYscale(-5.0/4*Math.PI, 3.0/4*Math.PI);

//heartCurveDraw1(512);

//heartCurveDraw2(512);

//heartCurveDraw3(512);

heartCurveDraw4(512);

}

Az eredmény

A szívgörbe önálló – swing, grafikus felhasználói felület, GUI – ablakban így jelenik meg:

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat – a matematikai háttértől eltekintve – a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 21-24. óra: Objektumorientált programozás 2. rész, valamint a 29-36. Grafikus felhasználói felület alkalmaihoz kötődik.

A 2D szívforma egyenletrendszerét erről a weboldalról választottam: Heart Curve – from Wolfram MathWorld. Egy merész továbbfejlesztési ötlet: a haladóknak megtalálható a 3D szívforma ábrázolása is: Heart Surface – from Wolfram MathWorld.

Sándor is blogolt már a Valentin-nap témában: Rómeó és Júlia. Ebből kiderül, hogy vajon ki szereti jobban a másikat: Rómeó vagy Júlia.

Kép élesítése effektus működése

2023. december 22.2023. november 20. Szerző: Kaczur Sándor

Ismert számos képfeldolgozó, képjavító effektus. Az egyszerűbb effektusok elérhetők ingyenes web- és mobil alkalmazásokban, PowerPointban. Az összetettebb (művészi) effektusokhoz, szűrőkhöz már érdemes professzionális eszközt használni, ilyen például az Adobe Photoshop. Ezek a belépő szint képeffektusai kulcsszavakban: élesítés (sharpen), homályosítás (blur), elmosódás (gaussian blur), folyadékszerű rajz (liquid), olajfestmény (oil painting), öregítés (sepia), szürkeskála (grayscale).

Lássuk, hogyan valósítható meg Java programozási nyelven a kép élesítése!

A kép adatszerkezete

Adott egy képfájl. Formátuma a tipikus, feldolgozhatók (JPG, GIF, PNG, WebP) egyike. Ezek rasztergrafikus képformátumok. Lekérdezhető a dimenziója: ez képpontban (pixelben) jelenti a kép szélességét (width) és a kép magasságát (height). A vászontechnika meghatározza a kép origóját (0, 0) és a képpontok kétdimenziós koordinátapárját. A kép origója a bal felső sarokban van. A kép oszlopai (column) jobbra haladva növekvő módon, a kép sorai (row) lefelé haladva növekvő módon számozottak. Egy pixel koordinátapárja (c, r) alakban írható le. Minden pixel három szín kombinációjaként áll elő (r, g, b). Másképpen: a piros, zöld és kék összetevők aránya alapján meghatározott. A tipikus színmélység alapján a színek külön-külön 256-félék lehetnek, és ezeket 0-tól 255-ig egész szám képviseli. A 0 az adott szín hiányát, a 255 a szín teljes intenzitását jelenti.

A kép élesítéséhez használható szűrőmátrixok

A kép élesítése során szűrőt alkalmazunk a kép belső pixeleire. A kép 4 szélén lévő pixeleket nem változtatjuk. Többféle szűrő közül választhatunk, íme két példa:

A három színösszetevőre külön-külön kell alkalmazni a szűrőt. Az aktuális pixel – amire alkalmazzuk a szűrőt – a 3×3-as mátrix középső eleméhez igazítva szorzóértékeket tartalmaz. A konkrét eset: az a mátrix esetén az 5 érték a 2. sor 2. oszlopában helyezkedik el; ennek a közvetlen szomszédos pixeleire a -1 értékek, átlós szomszédaira pedig a 0 értékek vonatkoznak. Eredményül a szűrt pixel színeit kapjuk meg külön-külön. Ha a kapott értékek kisebbek 0-nál, akkor nullázzuk őket. Ha a kapott értékek nagyobbak 255-nél, akkor beállítjuk azokat 255-re. Az a szűrőmátrix kevésbé élesít, a b szűrőmátrix erősebben élesít.

Természetesen sok más képélességhez köthető szűrő is van még. Olyanok is vannak, ahol nem csak a közvetlen szomszédos pixeleket veszi figyelembe az algoritmus. További kulcsszavak a témához kötődően: digitális képfeldolgozás, lokális operátor, korreláció, konvolúció, átlagszűrő, mediánszűrő, zajszűrő, Laplace-szűrő.

A kép élesítését megvalósító Java forráskód-részlet

A fenti a mátrixot a SHARP_FILTER konstans kétdimenziós tömb tárolja. A paraméterként átvett BufferedImage típusú img1 objektum kép pixeleinek végigjárását ütközőként segíti a w szélesség és h magasság. A data egydimenziós tömb sorfolytonosan tárolja a kép pixeleit. Az if elágazó utasítás igaz ága kezeli a kép 4 szélét (változatlanul hagyott másolt színek). Az if hamis ága a belső pixelekre alkalmazza a szűrőmátrixot. A red, green, blue változók tartalmazzák az aktuális pixel színeit, amelyekbe az eredeti pixelre alkalmazott szűrő által szorzott értékek kerülnek, „belekényszerítve” a 0-255 zárt intervallumba. Végül az eredményül visszaadott img2 kép pixelei kerülnek beállításra. Az alábbi sharpenEffect() függvény mindezt megoldja az alábbiak szerint:

public static BufferedImage sharpenEffect(BufferedImage img1) {

final int[][] SHARP_FILTER={

{ 0, -1, 0},

{-1, 5, -1},

{ 0, -1, 0}

};

Color[][] colorArray=new Color[3][3];

int w=img1.getWidth(), h=img1.getHeight(), i=0;

int[] data=new int[w*h];

for(int y=0; y<h; y++)

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

if(y==0 || x==0 || y==h-1 || x==w-1)

data[i]=img1.getRGB(x, y);

else {

for(int c=y-1; c<=y+1; c++)

for(int r=x-1; r<=x+1; r++)

colorArray[x-r+1][y-c+1]=new Color(img1.getRGB(r, c));

int red=0, green=0, blue=0;

for(int c=0; c<=2; c++)

for(int r=0; r<=2; r++) {

red+=SHARP_FILTER[r][c]*colorArray[r][c].getRed();

green+=SHARP_FILTER[r][c]*colorArray[r][c].getGreen();

blue+=SHARP_FILTER[r][c]*colorArray[r][c].getBlue();

}

red=(red<0)?0:(red>255?255:red);

green=(green<0)?0:(green>255?255:green);

blue=(blue<0)?0:(blue>255?255:blue);

Color c2=new Color(red, green, blue);

data[i]=c2.getRGB();

}

i++;

}

BufferedImage img2=

new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);

img2.setRGB(0, 0, w, h, data, 0, w);

return img2;

}

A metódus meghívása a fájlkezelést is tartalmazó vezérlőmetódusban például így történhet:

public static void main(String[] args) {

try {

BufferedImage imageSource=ImageIO.read(

new File("./images/Traditional-Japanese-Garden.jpg"));

BufferedImage imageSharpen=sharpenEffect(imageSource);

ImageIO.write(imageSharpen, "jpg",

new File("./images/Traditional-Japanese-Garden-sharpen.jpg"));

}

catch(Exception e) {

}

Az eredeti és élesített képek összehasonlítása

A bal oldalon az eredeti kép, a jobb oldalon az a mátrixszal élesített kép látható:

A bal oldalon az eredeti kép, a jobb oldalon a b mátrixszal élesített kép látható:

A látvány alapján fontos kiemelni, hogy másképpen is lehet összehasonlítást végezni. Például: színtérkép, színmélység, színösszetevők aránya (hisztogram).

Ötletek továbbfejlesztésre

Konzolos program átvehetné parancssori paraméterként a szűrőmátrixot, vagy annak nevét, kódját, egyes értékeit.
Grafikus felületű programban vízszinten JScrollBar GUI komponens(ek) segítségével paraméterezhető, kigörgethető lehetne a szűrőmátrix szélsőértéke(i).
A fenti effektek a kép összes pixelét érintik. GUI felületen megoldható az is, hogy ki tudjuk jelölni a kép egy-egy részét, amire alkalmazni szeretnénk az effektek. Ez a kijelölés többféle lehet, például téglalap alakú, szabálytalan, átlátszó, adott vagy adotthoz hasonló árnyalatú színű, vagy valaminek a körvonala.
Egy mappában lévő összes képre alkalmazható effekt, előnézettel, képfájlonként megerősítéssel, jóváhagyással, csoportos kijelöléssel, szűrővel.

Szürkeskála effekt megvalósítása és tesztelése az alábbi forráskód-részlettel:

Color c1=new Color(img1.getRGB(x, y));

int gray=(int)

(0.21*c1.getRed()+0.72*c1.getGreen()+0.07*c1.getBlue());

Color c2=new Color(gray, gray, gray);

Homályosítás effekt megvalósítás és tesztelése a 4 élszomszéd színeinek átlagolásával, így:

Color cTop=new Color(img1.getRGB(x, y-1)),

cRight=new Color(img1.getRGB(x+1, y)),

cBottom=new Color(img1.getRGB(x, y+1)),

cLeft=new Color(img1.getRGB(x-1, y));

int r=(cTop.getRed()+cRight.getRed()+

cBottom.getRed()+cLeft.getRed())/4,

g=(cTop.getGreen()+cRight.getGreen()+

cBottom.getGreen()+cLeft.getGreen())/4,

b=(cTop.getBlue()+cRight.getBlue()+

cBottom.getBlue()+cLeft.getBlue())/4;

Color c2=new Color(r, g, b);

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A Java SE szoftverfejlesztő tanfolyamunkon, a szakmai modul Objektumorientált programozás témakörét követő 29-36. óra Grafikus felhasználói felület alkalmain már tudunk egyszerűbb GUI programot tervezni, kódolni, tesztelni, kiegészítve a 37-44. óra Fájlkezelés alkalmaihoz kötődő példaprogramokkal.

Galéria véletlen sorrendben

2023. november 2.2023. augusztus 11. Szerző: Kiss Balázs

Adott egy mappában lévő sok-sok képfájl, többféle formátumban, kiterjesztéssel. A feladat az, hogy időzítve jelenítsük meg ezeket a képeket véletlen sorrendben saját fejlesztésű Java program segítségével. A tervezés során áttekintünk többféle lehetőséget. Bemutatjuk a megoldáshoz szükséges lépéseket és a program működését.

A program tervezése

A szükséges bemeneti adatok

Egy mappa, abszolút vagy relatív útvonal, ahol a képfájlok megtalálhatók. A mappa átvehető a program paramétereként (ha parancssorban meghívva átadjuk) vagy lehet az aktuális mappa (ahonnan a programot jar fájlként elindítjuk). A program a mappában közvetlenül megtalálható képeket olvassa be. Az ott található almappákba nem megy bele.
A képfájlok különböző kiterjesztéseit tárolni kell. Többféle is lehet, így ehhez szükséges alkalmas adatszerkezet. A listában nem szereplő kiterjesztéssel rendelkező fájlok nem kerülnek feldolgozásra.
Érdemes a képfájlokat egy lépésben betölteni a memóriába. Így a program takarékos erőforrásként bánik a tárhellyel (merevlemez, pen-drive, SSD, hálózati meghajtó). Csak egyszer dolgozza fel (olvassa végig) a mappát. Feltételezzük, hogy a képfájlok beférnek a memóriába.
A program teljes képernyős, amiből elérhető a rendelkezésre álló terület mérete, ahol megjeleníthetők a képek. A program a betöltött képfájlok méreteihez is hozzáfér. Ez a méret kétféle lehet: bájtban kifejezhető a képfájl elfoglalt tárhelye, illetve pixelben kifejezhető a képfájl dimenziója (másképpen a megjelentéséhez szükséges terület mérete a képernyőn).

Hogyan működik a program?

Egyszerre egy kép jelenik meg. Időzítő befolyásolja a képfájlok közötti váltást. Meghatározza, hogy a képfájlok meddig látszanak (másképpen: eltelt idő, késleltetés, várakoztatás). A swing GUI-hoz tartozó időzítőt kell hozzá használni.
A program alkalmazkodik a képernyő, kijelző felbontásához, képarányához. A program végtelenítve működik, Alt + F4 billentyűkombinációval lehet kilépni belőle.
A képfájlok megjelenítésük során optimálisan, dinamikusan kitöltik a rendelkezésre álló téglalap alakú területet. A túl kicsi képeket nagyítani kell. A túl nagy képeket kicsinyíteni kell. Mindezt úgy, hogy a képarányt (aspect ratio) meg kell tartani, hogy a képek ne torzuljanak el. Az alábbi három példa balról-jobbra mutatja az optimális kitöltést, illetve azt a két esetet, ami akkor történik, amikor a kép méretéhez képest a megjelenítésre használható terület túl magas vagy túl széles:
A galériába tartozó képek közötti véletlen sorrendet meg kell oldani. A program a memóriába betöltött képek sorszámai alapján valósítja meg a véletlenszerű kiválasztást. A sorszámok összekeverednek. Egymás után nem jöhet ugyanaz a kép többször. Ha a képek „elfogynak”, akkor a program végtelenített működése szerint a képek sorszámai újra összekeverednek és „lejátszásra kerülnek”.

A program megvalósítása

A mappát a java.io csomag File osztályából létrehozott folder objektum tárolja (a "./" szövegliterál jelöli az aktuális mappát). A feldolgozandó képfájlok kiterjesztéseinek listáját egy dinamikus tömbből létrehozott generikus lista oldja meg: ArrayList<String> imageFileExtensionList=new ArrayList<>(Arrays.asList("JPG", "JPEG", "PNG", "GIF")). Egy képfájl memóriabeli tárolását a java.awt.image.BufferedImage típus valósítja meg, amelyekből szintén generikus lista épül: ArrayList<BufferedImage> imageList. A grafikus felhasználói felülethez tartozó javax.swing csomagbeli Timer osztály szükséges, például 2 mp-es várakoztatás és eseménykezelés: timer=new Timer(2000, (ActionEvent) -> { showRandomImage(); }). A GUI JFrame leszármazott keretobjektum. A grafikus felhasználói felület a teljes képernyőt elfoglalja: setExtendedState(MAXIMIZED_BOTH) és setUndecorated(true). A keretre egyetlen JLabel típusú, fekete hátterű lbImage objektum kerül, az alapértelmezett határmenti elrendezésmenedzser közepére (vízszintesen és függőlegesen egyaránt). A képfájlok sorszámai (a későbbi véletlen kiválasztáshoz) az imageIndexList generikus listába/kollekcióba kerülnek. Az index változó jelöli az aktuális, memóriába betöltött képfájl sorszámát, ami kezdetben nulláról indul.

A képfájlok betöltése az alábbiak szerinti:

private void createImageList() {

File[] imageArray=folder.listFiles((File path) -> {

String extension=path.getName().toUpperCase().

substring(path.getName().lastIndexOf(".")+1);

return imageFileExtensionList.contains(extension);

});

try {

for(int i=0; i<imageArray.length; i++) {

imageList.add(ImageIO.read(imageArray[i]));

imageIndexList.add(i);

}

Collections.shuffle(imageIndexList);

}

catch(IOException e) {

}

A fájlok kiterjesztésének szűrése a FileFilter interfész accept() metódusának megvalósításával történik. A fenti forráskódban mindez tömör, lambda kifejezéssel (művelettel) valósul meg. A fájlszűrőn az képfájl megy át, aminek a nagybetűssé alakított kiterjesztését tartalmazza az imageFileExtensionList kollekció. Az i-edik képfájl memóriába való betöltését az ImageIO osztály statikus read() függvénye oldja meg. A képfájlok sorszámainak véletlen összekeverése kezdetben megtörténik: Collections.shuffle(imageIndexList). A fájlkezelés miatt kötelező kivételkezelést most – itt a szakmai blogban – nem részletezzük.

Az időzítő eseménykezelése, a 2 másodpercenkénti képváltás így valósul meg:

private void showRandomImage() {

BufferedImage img=imageList.get(imageIndexList.get(index));

Dimension d=getScaledDimension(new Dimension(

img.getWidth(), img.getHeight()), lbImage.getSize());

ImageIcon imageIcon=new ImageIcon(img.getScaledInstance(

(int)d.getWidth(), (int)d.getHeight(), Image.SCALE_SMOOTH));

lbImage.setIcon(imageIcon);

index++;

if(index==imageIndexList.size()) {

Collections.shuffle(imageIndexList);

index=0;

}

A program alábbi metódusa felel a képarányhoz kötődő műveletekért:

private Dimension getScaledDimension(

Dimension imageSize, Dimension area) {

double widthRatio=area.getWidth()/imageSize.getWidth();

double heightRatio=area.getHeight()/imageSize.getHeight();

double ratio=Math.min(widthRatio, heightRatio);

return new Dimension((int)(imageSize.width*ratio),

(int)(imageSize.height*ratio));

}

A program tesztelése

Érdemes lehet tesztelni nem ajánlott (rossz) megoldásként azt, hogy a program az időzítőnek megfelelően, dinamikusan olvasná be a képfájlokat, amivel lényegesen kevesebb memóriát igényelne.
Van-e reális korlát arra, hogy mennyi, mekkora képek „férnek el” a memóriában?
Hogyan befolyásolja a képfájlok száma és az általuk elfoglalt tárhely a program indulását?
Mi történik, ha nincs megfelelő kiterjesztésű képfájl a mappában? És ha több 1000 kép van benne?
Hogyan jelennek meg (megjelennek-e) az animációt tartalmazó képfájlok? Például a GIF képformátum nem csak statikus egyetlen képet tartalmazhat, hanem lehet animált is.
Teljesen megvalósul-e a reszponzivitás? Ha igen, mi indokolja? Ha nem, miért nem és hogyan lehetne megoldani?

Ha átmenetileg kikapcsoljuk a teljes képernyős megjelenítést, akkor könnyen tesztelhetővé válik a megvalósuló reszponzivitás. Másképpen a program dinamikusan alkalmazkodik a rendelkezésre álló (rajzolható) terület méreteihez (szélesség és magasság):

A program továbbfejlesztési lehetőségei

A program rekurzívan bejárhatná a folder által megjegyzett útvonalból kiindulva a teljes (al)mappaszerkezetet.
A program paraméterezhető lehetne a képfájlok kiterjesztéseivel. Akár konfigurációs fájlból is beolvashatná az imageFileExtensionList adatszerkezetet, például XML, JSON formátumban is.
A program ellenőrizhetné, hogy a mappában lévő összes kép befér-e a memóriába. A program kezelhetne ehhez kötődően többféle limitet: például az első 100 db képet töltené be, és/vagy csak annyi képet tölt be, ami belefér például 64 MB-ba.
A program mutathatná folyamatindikátorral induláskor a képfájlok betöltését. Vagy betölthetné például az első 5 db-ot és háttérszálon a többit, amíg az első 5-öt „lejátssza”.
Ha például a program 10 képet tölt be mappában lévő képfájlokból, akkor ezek 0-tól 9-ig sorszámozódnak. A sorszámok összekeverve következnek. Ha az első menetben az utolsó kép sorszáma például a 7 volt, akkor a következő ismétlődő menet nem kezdődhetne 7-tel.
A programból ki lehetne lépni az Esc billentyűvel is. KeyListener interfésszel megoldható.
A program kezelhetne egyéb képfájlformátumokat is: például animált GIF, statikus WebP, animált WebP.
A program könnyen kiegészíthető prezentációk diáinak időzített/felülbírált megjelenítésére.
A program által beolvasott képfájlokból generálható PDF fájl is (rácsos sablonnal, például 6 db kép laponként). A feldolgoztt mappában lévő képfájlok könnyen feltölthetők FTP szerver adott mappájába, átméretezhetőek csoportosan, elküldhetők nyomtatási sorba is.
Érdemes megismerni a JDK-n kívüli egyéb, képfájlokat kezelő osztályok, csomagok funkcióit, például: OpenIMAJ, TwelveMonkeys ImageIO.
A swing-es felület kiegészíthető mappatallózással, egyéni fájl(típus)szűrőkkel, paraméterezhető lehet a véletlenszerű kiválasztás algoritmusa, változtatható az időzítés késleltetése.
Mivel a program teljes képernyős, így elrejthető az egérmutató.
A képek „lejátszásából” lehetne generálni animált GIF-et.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A Java SE szoftverfejlesztő tanfolyamunkon, a szakmai modul Objektumorientált programozás témakörét követő 29-36. óra Grafikus felhasználói felület alkalmain már tudunk egyszerűbb animációs, szimulációs programot tervezni, kódolni, tesztelni.

Beszámoló: it-tanfolyam.hu STEM nyári tábor 2023

2023. augusztus 5.2023. július 28. Szerző: Kaczur Sándor

A STEM mozaikszó eléggé közismert: a tudományos-technológiai tudományágakat (természettudomány, technológia, mérnöki tudomány és matematika) foglalja egybe, interdiszciplináris megközelítésben. A STEM területén való elmélyedés során a hangsúly nem a mit tanulunk/tanítunk, hanem inkább a hogyan tanulunk/tanítunk. Nem azonnal ad kézzel fogható válaszokat, de kitartó próbálkozással – saját élménnyel – elérhető az eredmény.

Az it-tanfolyam.hu oktatói csapata 2023-ban először hirdetett STEM nyári tábort. Erről számolunk be röviden ebben a blog bejegyzésben. Tervezzük, hogy a jövőben rendszeresen fogunk szervezni STEM nyári tábort.

A STEM nyári tábor koncepciója

2023. nyarán 4 turnusban hirdettünk programozás fókuszú STEM nyári tábort:

1. turnus: július 3-7-ig,
2. turnus: július 10-14-ig,
3. turnus: július 17-21-ig,
4. turnus: július 24-28-ig.

Előzetes tudás- és igényfelmérést végeztünk, így alakítottunk ki 3 db csoportot, ezek: Java kezdő, Python kezdő, Python haladó. A kiinduló célcsoportot tanfolyamaink karrierváltó hallgatóinak gyermekei jelentették, akik mellé toboroztunk még. A korosztály a 16-20 éves diákok voltak a 11-14. évfolyamról. A 11-12. évfolyamosok közül sokan informatika, digitális kultúra érettségi előkészítő fakultációra jelentkeztek, jártak, járnak és ebből érettségiznek/érettségiztek. A már korábban érettségizett 13-14. évfolyamosok körülbelül fele az OKJ utód szakmajegyzékhez tartozó szakképzésben tanult.

Mindegyik turnus azonos tematikával valósult meg. Turnusonként 3 db párhuzamos, 10-12 fős csoportokat indítottunk. Voltak közös elméleti programok, szakmai kirándulás, illetve külön-külön Java és Python nyelven megvalósuló gyakorlati programok, valamint projektbemutatóra is sor került. Igyekeztünk érinteni sokféle STEM területet: fizika, kémia, biológia, csillagászat, térinformatika, mesterséges intelligencia, szimuláció, játékprogramok, matematika, orvostudomány; mindegyiket a programozáshoz kapcsolva. Végeztünk tervezést, kódolást, tesztelést is. Belefért némi pályaorientáció is.

A STEM nyári tábor órarendje

Turnusonként 4 oktató kollégával és vendégelőadókkal hétfőtől-péntekig minden nap 8 és 18 óra között biztosítottuk a jelenlétet, felügyeletet. 40 órában szakmai programokat (elmélet+gyakorlat) kínáltunk. Reggelenként és késő délutánonként 1-1 órában offline, egyéni vagy csoportos játékok voltak kipróbálhatók. Ez mindösszesen 50 órát jelentett. Délelőttönként 20, 30 és 60 perces programokat terveztünk, délutánonként 120 és 240 perceseket. Szerdára szakmai kirándulást, gyárlátogatást ütemeztünk be. Íme az órarend áttekintő formában:

Íme az órarend naponként lapozható formában, benne a részletekkel:

Hétfő

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
STEM1 - Kaczur Sándor, Kiss Balázs, Hollós Gábor, Szegedi Kristóf: A STEM tábor heti programjának ismertetése, a STEM megvalósult koncepció, a STEM bevezetése, a célok ismertetése, ILIAS megismerése
E1 - Kiss Balázs: Mi az ipar 4.0? Mi az okos gyár? Hogyan tovább: ipar 5.0?
S1 - Kaczur Sándor: Optikai csalódások, fiziológiai illúziók, kognitív illúziók, elméleti áttekintés példákon keresztül
S2 - Hollós Gábor: Sztereogramok szerkezete, készítése online eszközökkel
G1 - Szegedi Kristóf: Gondolkodjunk logikusan! - CHOO+CHOO=TRAIN
G2 - Kiss Balázs: Gondolkodjunk logikusan! - Hány éves a kapitány?
G3 - Kaczur Sándor: Gondolkodjunk logikusan! - Ki tart halat? - Einstein fejtörője - interaktív feladatmegoldás
E2 - Kiss Balázs: A szoftverfejlesztés és -tesztelés szakterületei (komolyan és mémekkel egyaránt)
Ebéd1 - Menüebéd a közeli étteremben és közös séta oda-vissza
S3 - Kaczur Sándor: Optikai csalódások programozása és tesztelése Java nyelven (Swing)
S4 - Hollós Gábor: Optikai csalódások programozása és tesztelése Python nyelven (TKinter)
S5 - Kiss Balázs: Sztereogramok programozása és tesztelése Python nyelven (TKinter)
M1 - Kiss Balázs: Matematika középszintű érettségi feladatok megoldása programozással Java nyelven
M2 - Hollós Gábor: Matematika középszintű érettségi feladatok megoldása programozással Python nyelven
NXT1 - Kaczur Sándor: Kreatív problémamegoldás robotokkal - LEGO MINDSTORMS NXT 2.0
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok és társasjátékok élményszerű kipróbálása, diákok távozása

Kedd

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
E3 - Kaczur Sándor: Algoritmus vesebeteg-donorok párosítására: lehetőségek, korlátok, hatékonyság, logisztika
S6 - Szegedi Kristóf: Gáz- és folyadékmodellek szimulációja, elméleti áttekintés példákon keresztül
S7 - Kiss Balázs: Denevérek a barlangban esettanulmány áttekintése és közös ötletelés a továbbfejlesztési lehetőségeken
S8 - Szegedi Kristóf: Hóesés szimuláció tervezése, paraméterek módosításával Python program tesztelése
Játék3 - Kiss Balázs: A World 3D játékprojekt tesztelése, különböző nehézségi szinteken, gráfbejárás algoritmusainak felfedezése
E4 - Hollós Gábor: Miért érdemes állásbörzékre járni? Miért érdemes ismerni a TIOBE, a PYPL és az IEEE Spectrum indexeit/rangsorait, valamint az Indeed és a Trendy Skills álláskereső portálokat?
E5 - Németh András, Falus Anita, Tóth-Szabó Tamás: Kezdő szoftverfejlesztők munkaerőpiaci tapasztalatai (Java tanfolyamaink alumni hallgatóinak beszámolója)
Ebéd1 - Menüebéd a közeli étteremben és közös séta oda-vissza
T1 - Kiss Balázs: Gyűjtögető robotok kommunikációjának működése, tervezése, lehetőségek áttekintése
T2 - Szegedi Kristóf: A rajintelligencia lehetőségei a robotok közötti kommunikáció testre szabása esetén
M3 - Kiss Balázs: Matematika középszintű érettségi feladatok megoldása programozással Java nyelven
M4 - Hollós Gábor: Matematika középszintű érettségi feladatok megoldása programozással Python nyelven
NXT2 - Kaczur Sándor: Kreatív problémamegoldás robotokkal - LEGO MINDSTORMS NXT 2.0 (NXT1 folytatása)
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok és társasjátékok élményszerű kipróbálása, diákok távozása

Szerda

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
E6 - Kiss Balázs: Hogyan működik a projektmenedzsment a szoftveripari gyakorlatban? Hogyan egyensúlyoz(hat)unk az idő, erőforrás, költség dimenzióiban? Milyen az optimális projekt?
S9 - Kaczur Sándor: Biológiai szimulációk működése, tervezési szempontjai, elméleti áttekintés példákon keresztül
S10 - Szegedi Kristóf: Életjáték Conway-féle szimulációja, extrém helyzetek tesztelése különböző alakú síkbeli alakzatok kitöltése során, pöttyök és csíkok tesztje, iteratív és rekurzív megoldások tesztje
S11 - Hollós Gábor: Ragadozó és zsákmány modell működése, kísérlet az optimális paraméterezésére, tesztelés ProgCont API-val
T3 - Kaczur Sándor: A mesterséges intelligenciával szembeni reális igények, elvárások, hol tartunk, milyen technológiai és etikai határok definiálhatók, ésszerűen mi várható közeljővőben
LEGO1 - Utazás autóbusszal a Budapest-Nyíregyháza útvonalon és útközben a LEGO történetéről szóló ismeretterjesztő (20 perc) és a dániai Billund városban található LEGOLAND attrakcióit bemutató (10 perc) filmek megtekintése
Ebéd2 - Szendvicsebéd az autóbuszon elfogyasztva
LEGO2 - Szakmai gyárlátogatás a LEGO Manufacturing Kft. hazai játékgyárában, gyártósor megtekintése és logisztikai folyamatok megismerése
LEGO3 - Utazás autóbusszal a Nyíregyháza-Budapest útvonalon és útközben a Végtelen határok filmsorozat A tudat folyama című epizódjának (43 perc) megtekintése és elemzése
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok és társasjátékok élményszerű kipróbálása, diákok távozása

Csütörtök

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
VR1 - Kiss-Bakos Evelin: Repülőgép-szimulátor teszt Oculus Quest 2 VR szemüvegben, egyéni küldetés teljesítése
S12 - Szegedi Kristóf: Sakkszimultán - offline és online egyaránt
T4 - Kaczur Sándor: Heurisztikus célfüggvények gráfreprezentáció esetén, általánosan használható és csak speciális feltételek esetén működő megvalósítások tesztelése Google Cloud Platformon
E7 - Hollós Gábor: Interaktív tematikus térképek paraméterezése Java nyelven OpenWeatherMap kiegészítéssel
E8 - Hollós Gábor: Interaktív tematikus térképek paraméterezése Python nyelven OpenWeatherMap kiegészítéssel
VR2 - Kiss-Bakos Evelin: NASA űrkutatás misszió teszt Oculus Quest 2 VR szemüvegben, csoportos küldetés teljesítése
Ebéd1 - Menüebéd a közeli étteremben és közös séta oda-vissza
M5 - Kiss Balázs: Matematika középszintű érettségi feladatok megoldása programozással Java nyelven Reddit és Stack Overflow használatával
M6 - Hollós Gábor: Matematika középszintű érettségi feladatok megoldása programozással Python nyelven Reddit és Stack Overflow használatával
NXT3 - Kaczur Sándor: Kreatív problémamegoldás robotokkal - LEGO MINDSTORMS NXT 2.0 GitHub integrációval (NXT2 folytatása)
P1 - Szegedi Kristóf: Java projektfeladatok bemutatásának előkészítése, értékelési szempontok áttekintése, kooperatív csoportmunkában megvalósuló prezentáció elkészítése
P2 - Kiss Balázs: Python projektfeladatok bemutatásának előkészítése, értékelési szempontok áttekintése, kooperatív csoportmunkában megvalósuló prezentáció elkészítése, kezdő és haladó csoportok munkáinak összehasonlítása
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok és társasjátékok élményszerű kipróbálása, diákok távozása

Péntek

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
G4 - Kaczur Sándor: Logikus gondolkodás teszt
E9 - Kiss Balázs: Naprendszer szimuláció tervezése, kipróbálása, tesztelése
E10 - Kaczur Sándor: Lottószelvény-generálás Java és Python nyelveken, valamint ChatGPT segítségével, a módszerek összehasonlítása és hatékonyságuk elemzése
T5 - Hollós Gábor: Az OpenAI chat (ChatGPT) felépítése, működése (áttekintés UML-ben), használati útmutató és tesztelése
T6 - Kiss Balázs: Az OpenAI képgeneráló felépítése, működése, használati útmutató és tesztelése
P3 - Szegedi Kristóf: Java projektfeladatok bemutatásának előkészítése, kooperatív csoportmunkában megvalósuló prezentáció elkészítése (P1 folytatása)
P4 - Kiss Balázs: Python projektfeladatok bemutatásának előkészítése, kooperatív csoportmunkában megvalósuló prezentáció elkészítése, kezdő és haladó csoportok munkájának összehasonlítása (P2 folytatása)
STEM2 - Kaczur Sándor, Kiss Balázs, Hollós Gábor, Szegedi Kristóf: A STEM nyári tábor heti programjának összefoglalója, várható fejlődés, a STEM jövőbeli koncepciója, elért és távlati céljainak ismertetése
Ebéd1 - Menüebéd a közeli étteremben és közös séta oda-vissza
P5 - Szegedi Kristóf, Kiss Balázs: Java és Python projektfeladatok prezentációja (P3 és P4 folytatása), megvitatása, közös értékelése, nyílt program szülőknek, meghívott barátoknak, vendégeknek, kooperatív csoportmunka lezárása, oklevelek kiosztása, visszajelzések összegyűjtése, prezentációk, projektmunkák és fényképek archiválása ILIAS-on, beszámoló elkészítése
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása és diákok távozása

Előzetes tapasztalataink

Előzetes tapasztalatainkat több forrásból merítettük, inspirálódtunk:

a GINOP-3.1.1-VEKOP-15-2016-00001 projektben való részvétel során, beszámoló: Programozd a jövőd! – IT a jövőd (2016-2023)
a STE(A)M Platform pályázatban (Towards a European STE(A)M Platfom, EACEA/36/2018) való közreműködés során (2020-2022),
számtalan digitális pedagógus továbbképzésből, például amiről írtunk a szakmai blogban: LEGO Education módszertani képzés / Robotika Mindstorms EV3 robottal
a 2020/2021-es tanévben szervezett Python tanfolyamunk tervezése és megvalósítása során, amiről beszámoltunk a Multimédia az oktatásban 2021 konferencián szakmai előadás és szakmai cikk formájában,
tanfolyamaink tananyagaihoz tartozó esettanulmányaink, a nyári táborhoz főként a Java SE szoftverfejlesztő tanfolyam tematikájához kötődve, szakmai és orientáló moduljaihoz egyaránt.

Köszönetnyilvánítás

Köszönjük résztvevő diákjainknak az aktivitást, a lelkesedést, a sok-sok elgondolkodtató kérdést, az offline kapott/szerzett élményeket, a pozitív visszajelzéseket.

Szeretnék köszönetet mondani együttműködő partnereinknek: LEGO Manufacturing Kft., REGIO Játékkereskedelmi Kft., Revolt Kereskedelmi Kft., Pannon Kincstár Humán Szakképző Központ.

Végül szeretnék köszönetet mondani minden oktató kollégámnak konstruktív részvételüként, kitartásukért a projekt teljes életciklusában. A tervezési, a szponzorszerző, a promóciós és a megvalósítási szakaszokban egyaránt 2023. április elejétől július végéig. Kiemelem korábbi és az aktuális projekthez kötődő tananyagfejlesztési tevékenységüket. A sikeresen lezárt projektünket augusztusban kipihenjük. 😉