ciklusok - címke - it-tanfolyam.hu

Dr. Sheldon Cooper kő-papír-olló-gyík-Spock játéka

2024. április 1.2024. április 1. Szerző: Kaczur Sándor

Dr. Sheldon Cooper karakterét nem kell bemutatni. Ha a kockáknak döntéseket kell hozniuk, akkor az Agymenők (The Big Bang Theory) sorozatban többször is előkerül a kő-papír-olló-gyík-Spock játék.

A 2. évad 8. epizódjában – amelynek címe Fogd a nőt, és fuss! (The Lizard–Spock Expansion) – ismerjük meg a játékszabályt és rögtön alkalmazásra is kerül. Raj és Sheldon megpróbálja eldönteni, hogy melyik sci-fi sorozat a (leg)jobb, illetve Howard és Sheldon így próbálnak osztozni a vacsora maradékán. Végül az 5. évad 17. epizódjában – amelynek címe Itt a festmény, hol a festmény! (The Rothman Disintegration) – újra hallhatjuk a játékszabályt. Ekkor Kripke és Sheldon egy egyetemi iroda sorsáról (kié legyen) próbál dönteni.

A kő-papír-olló-gyík-Spock játékszabály

Vajon hogyan bővül ki a klasszikus kő-papír-olló játékszabálya további két kézjel/fegyver hozzáadásával? Íme a játékszabály videóban:

Íme a játékszabály szövegesen:

Az olló elvágja a papírt,
a papír bevonja a követ,
a kő agyonüti a gyíkot,
a gyík megmarja Spockot,
Spock eltöri az ollót,
az olló lefejezi a gyíkot,
a gyík megeszi a papírt,
a papír cáfolja Spockot,
Spock feloldja a követ,
a kő eltöri az ollót.

Ugye mi sem egyszerűbb? 🙂

A játékszabálynak számos grafikus ábrázolása is van. Ezeken többnyire irányított gráf csomópontjai mutatják a kézjeleket és a nyilak iránya mutatja, hogy mi mit győz le. Például a gyíktól Spock felé mutató jelzi, hogy a gyík megmarja (azaz legyőzi) Spock-ot. Íme az egyik ábra:

A kő-papír-olló-gyík-Spock játék szimulációja Java programmal

Az objektumorientált tervezés egyik lehetősége az öröklődés beépítése. Közös pontokat, funkcionalitást keresünk. Ezeket beépítjük az ősosztályba és az utódokban kiegészítjük, testre szabjuk. Kiindulunk az alábbi absztrakt Dontes ősosztályból:

abstract class Dontes {

private static final String[] DONTES={

"kő", "papír", "olló", "gyík", "Spock"}; //-1: döntetlen

// 0 1 2 3 4

protected static int veletlenDontes() {

return (int)(Math.random()*5); //0-4

}

private String dontesEredmeny(int d) {

return d==-1 ? "döntetlen" : DONTES[d]+ " nyert";

}

protected String kiiras(int d1, int d2) {

if(d1<-1 || d1>=DONTES.length || d2<-1 || d2>=DONTES.length)

throw new IllegalArgumentException("Hiba! Érvénytelen döntés.");

return DONTES[d1]+" és "+ DONTES[d2]+": "+

dontesEredmeny(eredmeny(d1, d2));

};

protected int eredmeny(int d1, int d2, int d3) {

return eredmeny(d1, eredmeny(d2, d3));

}

public abstract int eredmeny(int dontes1, int dontes2);

}

A konstans DONTES tömb (indexelhető adatszerkezet) tárolja a kézjelek/fegyverek elnevezését. Ezek közül választ véletlenszerűen a veletlenDontes() függvény. Az eredményt ki kell tudni írni a konzolra, illetve kezelni kell a döntetlent is. Ezekért közösen felelnek a dontesEredmeny() és a kiiras() függvények. A túlterhelt metódusokként létrehozott eredmeny() függvények kezelik a 2 illetve 3 játékos esetén a döntéseket. A háromparaméteres függvény visszavezet a kétparaméteres esetre. Utóbbi metódus – mivel absztrakt – csak az utódosztályban valósul meg. Így lehetővé válik a játékszabály többféle megvalósítása.

1. megoldás

Az első megoldás során adatszerkezet nélkül valósul meg a játékszabály a KoPapirOlloGyikSpockV1 utódosztályban:

class KoPapirOlloGyikSpockV1 extends Dontes {

@Override

public int eredmeny(int d1, int d2) {

if(d1==d2) //döntetlen

return -1;

return (d1==2 && d2==1) || //Az olló elvágja a papírt,

(d1==1 && d2==0) || //a papír bevonja a követ,

(d1==0 && d2==3) || //a kő agyonüti a gyíkot,

(d1==3 && d2==4) || //a gyík megmarja Spockot,

(d1==4 && d2==2) || //Spock eltöri az ollót,

(d1==2 && d2==3) || //az olló lefejezi a gyíkot,

(d1==3 && d2==1) || //a gyík megeszi a papírt,

(d1==1 && d2==4) || //a papír cáfolja Spockot,

(d1==4 && d2==0) || //Spock feloldja a követ,

(d1==0 && d2==2) ? //a kő eltöri az ollót.

d1 : d2;

}

2. megoldás

A második megoldás során a játékszabályt konstansként deklarált MATRIX szomszédsági -, csúcsmátrix, kétdimenziós tömb adatszerkezet tárolja. Ez alapján döntést tud hozni a KoPapirOlloGyikSpockV2 utódosztály.

class KoPapirOlloGyikSpockV2 extends Dontes {

private static final int[][] MATRIX={

// kő papír olló gyík Spock

/*kő*/ {0, 0, 1, 1, 0},

//A kő eltöri az ollót, a kő agyonüti a gyíkot,

/*papír*/ {1, 0, 0, 0, 1},

//a papír bevonja a követ, a papír cáfolja Spockot,

/*olló*/ {0, 1, 0, 1, 0},

//az olló elvágja a papírt, az olló lefejezi a gyíkot,

/*gyík*/ {0, 1, 0, 0, 1},

//a gyík megeszi a papírt, a gyík megmarja Spockot,

/*Spock*/ {1, 0, 1, 0, 0}

//Spock feloldja a követ, Spock eltöri az ollót.

};

@Override

public int eredmeny(int d1, int d2) {

if(d1==d2) //döntetlen

return -1;

return MATRIX[d1][d2]==1 ? d1 : d2;

}

A játékmenetért felelős vezérlés

10 lépésből álló játékmenetet hoz létre az alábbi vezérlés:

public class KoPapirOlloGyikSpock {

public static void main(String[] args) {

KoPapirOlloGyikSpockV1 jatekV1=new KoPapirOlloGyikSpockV1();

KoPapirOlloGyikSpockV2 jatekV2=new KoPapirOlloGyikSpockV2();

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

int d1=Dontes.veletlenDontes();

int d2=Dontes.veletlenDontes();

System.out.println(jatekV1.kiiras(d1, d2));

System.out.println(jatekV2.kiiras(d1, d2));

System.out.println();

}

Egyben tesztelés is: igazolja, hogy azonosan működik a két különböző megoldás.

Eredmény

Mivel minden véletlenszerűen alakul a játékban, ezért az alábbi csupán egy a sokféle lehetséges kimenet közül:

papír és gyík: gyík nyert

kő és kő: döntetlen

kő és papír: papír nyert

Spock és papír: papír nyert

olló és Spock: Spock nyert

kő és Spock: Spock nyert

papír és papír: döntetlen

gyík és Spock: gyík nyert

gyík és kő: kő nyert

A bejegyzéshez tartozó teljes forráskódot – többféle változatban is – 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ő szerkezetek, 9-12. óra: Metódusok, rekurzió, 13-16- óra: Tömbök, illetve a 17-24. óra: Objektumorientált programozás 1. és 2. rész alkalmaihoz kötődik.

PDF fájl készítése

2024. március 23.2024. március 22. Szerző: Kaczur Sándor

A PDF népszerű fájlformátum. Az Adobe cég 30+ éves szabványa. Hordozható: azaz minden eszközön, platformon ugyanúgy jelenik meg. Számos nézegető program támogatja, köztük böngészőprogramok is. A PDF rövidítés a Portable Document Format betűszava. Többnyire kimeneti formátumnak tekinthető. Az évek során folyamatosan fejlődött: ma már űrlapokat is tartalmazhat, elektronikusan aláírható, hitelesíthető, és hivatalos ügyek során is használják.

PDF fájl többféleképpen is készíthető. Például:

irodai szoftverek Mentés másként… menüpontjában,
Adobe Acrobat szoftverrel,
online alkalmazásokkal sokféle fájlformátum konvertálható PDF-be,
speciális célszoftverek is generálhatnak PDF fájlokat.

Utóbbi esetekre néhány példa:

online megvásárolt koncertjegyet e-mail csatolmányaként kapunk PDF-ben, ugyanígy számlát is róla,
online tanfolyamunk záró tesztjét követően letölthető tanúsítványt, badge-t, online IQ tesztünk eredményeként oklevelet kapunk PDF fájlként,
kérdőívek kitöltése során egyéni válaszainkat visszaigazolásként PDF-et kapunk, vagy a kérdőív kitöltési időszakának végén összesített eredményt, PDF riportot kapunk.

Java program készít PDF fájlt

Adatokra van szükség. Korábbi Munkakör, létszám, névsor lekérdezése blog bejegyzésünkben az Oracle HR sémából kétféleképpen is lekérdeztük a szükséges adatokat. Ezt érdemes előzetesen tanulmányozni, hogy a további tartalom könnyebben érthető legyen. A Java SE szoftverfejlesztő tanfolyam megközelítése alapján, az egyszerűbb SQL paranccsal előállított eredménytáblát a PDF generálása előtt még csoportosítani kell (munkakörönként). A Java adatbázis-kezelő tanfolyam megközelítése alapján, az összetettebb SQL paranccsal elkészített, denormalizált eredménytábla közvetlenül felhasználható.

A cél egy táblázat elkészítése, amely 3 oszlopból áll: munkakör, létszám és névsor. Az azonos munkakörű alkalmazottak névsora egy táblázat egyetlen cellájában legyen megjeleníthető. Az elkészült táblázatból készüljön PDF fájl.

A teendők lépésenként

Szükséges az iText csomag importálása: com.itextpdf.text. Korábbi változata az 5-ös, aktuális változata a 8-as. Előbbi nagyon elterjedt, utóbbi még kevésbé ismert. A továbbiakban a kötelező kivételkezeléshez kötődő forráskód-részletek bemutatásától eltekintünk.

Tehát adott az összes szükséges adat egy ArrayList<MunkakorLetszamNevsor> lista generikus listában. A POJO mindhárom szükséges és összetartozó tulajdonságot tárolja: String munkakor, int letszam, String nevsor.

Hasznos egy általánosan használható cella() függvény elkészítése, amely képes adott szöveget, adott betűmérettel, adott betűstílussal, adott igazítással „megjeleníteni”:

private PdfPCell cella(String szoveg, int betumeret,

boolean felkover, int igazitas)

throws DocumentException, IOException {

PdfPCell cella=new PdfPCell();

BaseFont betutipus=BaseFont.createFont(

BaseFont.HELVETICA, BaseFont.CP1250, BaseFont.EMBEDDED);

Paragraph bekezdes=new Paragraph(szoveg,

new Font(betutipus, betumeret, felkover?Font.BOLD:Font.NORMAL));

bekezdes.setAlignment(igazitas);

cella.addElement(bekezdes);

cella.setPadding(2);

cella.setVerticalAlignment(Paragraph.ALIGN_CENTER);

return cella;

}

Létre kell hozni a pdfFajl objektumot, beállítani a méretét és a margókat, illetve fájlba kell irányítani:

Document pdfFajl=new Document(PageSize.A4, 15, 15, 30, 20);

PdfWriter.getInstance(pdfFajl,

new FileOutputStream("./files/jelentes.pdf"));

pdfFajl.open();

Létre kell hozni a táblázat előtt megjelenő szöveget (ez nem a szövegszerkesztés szerinti valódi fejléc):

BaseFont betutípus=BaseFont.createFont(

BaseFont.HELVETICA, BaseFont.CP1250, BaseFont.EMBEDDED);

Paragraph fejlec=

new Paragraph("Jelentés", new Font(betutípus, 20, Font.BOLD));

fejlec.setAlignment(Paragraph.ALIGN_CENTER);

pdfFajl.add(fejlec);

Létre kell hozni a táblázatot, megfelelő beállításokkal:

PdfPTable tablazat=new PdfPTable(3);

tablazat.setWidthPercentage(85);

tablazat.setSpacingBefore(40);

tablazat.setWidths(new float[] {0.2f, 0.1f, 0.7f});

Létre kell hozni a táblázat fejlécét:

tablazat.addCell(

cella("Munkakör", 14, true, Paragraph.ALIGN_CENTER));

tablazat.addCell(

cella("Lét-\nszám", 14, true, Paragraph.ALIGN_CENTER));

tablazat.addCell(

cella("Névsor", 14, true, Paragraph.ALIGN_CENTER));

Végig kell haladni az adatokon és elő kell állítani a szükséges táblázatcellákat, végül le kell zárni a fájlt:

for(MunkakorLetszamNevsor mln: lista) {

tablazat.addCell(

cella(mln.getMunkakor(), 12, false, Paragraph.ALIGN_LEFT));

tablazat.addCell(

cella(""+mln.getLetszam(), 12, false, Paragraph.ALIGN_CENTER));

tablazat.addCell(

cella(mln.getNevsor(), 12, false, Paragraph.ALIGN_LEFT));

}

pdfFajl.add(tablazat);

pdfFajl.close();

A PDF fájl és a belekerülő táblázatobjektum szerkezete DOM-szerű, illetve azonos a grafikus felhasználói felület felépítése során használt AWT/swing konténerszemlélettel.

A felhasznált programozási tételek: sorozatszámítás, kiválasztás, megszámolás, kiválogatás, illetve kombináltan: csoportosítás, rendezés.

Az eredmény

Az elkészült PDF fájl másfél oldalas, itt letölthető, megtekinthető. A dokumentumról készült képernyőkép:

Továbbfejlesztési lehetőségek

Igényeinktől függően, illetve előzetes tapasztalatainkra és a meglévő tudásunkra építve számos ötlet merülhet fel. Mindhárom tanfolyam esetén testre tudjuk szabni azt az SQL parancsot, ami a szükséges adatokat lekérdezi. Az iText csomag helyett felfedezhetjük a PDF Clown, a PDFBox, illetve a Spire.PDF csomagok funkcionalitását is.

A Java SE szoftverfejlesztő tanfolyam tematikájához kötődve egyszerűbb dolgokat tudunk megvalósítani. Használhatunk további stílusokat: betűre, bekezdésre, cellára, táblázatra vonatkoztatva, színeket, szegélyeket. Többoldalas dokumentum esetén hozzáadhatunk oldalszámot, oldalszám / oldalak száma mezőt, tényleges fej- és láblécet, generálásra vonatkozó időbélyeget, képezhetjük szabály alapján a PDF fájl nevét, illetve tallózhatjuk annak helyét (hol jöjjön létre).
A Java EE szoftverfejlesztő tanfolyam tematikájához kötődve az előzőeken felül elhelyezhetjük a generált fájlt egy szerveren és elküldhetjük e-mailben a letöltéséhez szükséges URL-t. A letöltés korlátozható darabszámmal és időben is (például max. 3 db letöltés lehetséges a következő 48 órán belül). A PDF fájlba belekerülhet szöveges vízjel, céges logó és saját képként dinamikusan előállított grafikon. Például a JFreeChart grafikon készítése projekt swing-es GUI felületéből néhány utasítással készíthetünk JPG vagy GIF formátumú képet, ami könnyen beilleszthető PDF-be. Online, webes API szolgáltatás használatával az előállított PDF fájl tömöríthető, illetve belekerülhet QR kód, vonalkód is.
A Java adatbázis-kezelő tanfolyam tematikájához kötődve az előzőeken felül a JDBC alapú back-end kicserélhető JPA alapúra. A PDF láblécébe beleírhatjuk, hogy az adatbázis-szerveren kinek a nevében futott (DB User) az a lekérdezés, ami előállította a szükséges adatokat. Megoldható a generált PDF egyedi azonosítója, azaz kétszer nem állítható elő „ugyanaz”. Modulárisan továbbfejlesztve gyakorolhatjuk a tudatosan felépített MVC architekturális tervezési minta használatát. Limit feletti méretű PDF fájlt több kisebbre szétdarabolhatunk.

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

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ölcsönös ajándékozás véletlenszerűen

2023. december 1. Szerző: Kaczur Sándor

A kölcsönös ajándékozás időről-időre több közösségben is felmerül. Munkahelyi környezetben és iskolai csoportokban is (például: Télapó, karácsony). Hagyományos megközelítésben így hangzik a szabály: „húzzunk neveket a kalapból”. Másképpen: mindenki 1 ajándékot ad, mindenki 1 ajándékot kap és a sorsolás véletlenszerűen történik.

Készítsünk Java programot, ami megoldja a kölcsönös ajándékozást véletlenszerűen!

A neveket tároljuk el szövegfájlban ( nevsor10.txt). Soronként egy nevet. Ha különböznek, akkor elegendő a keresztnév. A soroknak/neveknek különbözniük kell. Ha szükséges, akkor hozzáírjuk a vezetéknevet, a vezetéknév első betűjét vagy sorszámot. Ezt a program beolvassa és megjegyzi egy szöveg típusú generikus nevsorLista nevű indexelhető adatszerkezetben. A nevek eredeti sorrendje nem befolyásolja a kiválasztást, mert a neveket a program összekeveri (helyben, véletlenszerűen, a shuffle() metódussal). Adott elemszámú lista indexelhető nullától elemszám-1-ig ( size()-1-ig).

List<String> nevsorLista=Files.readAllLines(

Paths.get(new File("./files/nevsor10.txt").getPath()));

Collections.shuffle(nevsorLista);

A szövegfájl olvasása, tartalmának betöltése során – az ékezetes karakterek miatt – előfordulhatnak karakterkódolási problémák. Ekkor használható a readAllLines() függvény túlterhelt változata esetén a Charset típusú második paraméter, például így: Charset.forName("ISO-8859-2"). A fájlkezeléshez kötelezően kivételkezelés is szükséges (ezt most nem részletezem).

1. megoldás

Az ajándékot adó-kapó párosokat a listában egymás mellett lévő i-edik (bal) és i+1-edik (jobb) nevek adják. Az adó az elsőtől az utolsó előttiig, a kapó a másodiktól az utolsóig léptethető. Kimarad az a pár, amikor az utolsó ad és az első kap. A lista indexei szerint az adók esetében a nulladik elemétől az utolsó előtti eleméig és a kapók esetében a lista első elemétől az utolsó eleméig jelenti a kiválasztást. Mindez könnyen megoldható for számláló ciklussal. A kimaradó pár ajándékot adó tagja a lista size()-1-edik eleme és kapó tagja a lista nulladik eleme. Ez a ciklus után egyszerű kiírással megoldható.

System.out.println("Ajándékozás\nNévsor: "+nevsorLista);

for(int i=0; i<=nevsorLista.size()-2; i++)

System.out.println(

nevsorLista.get(i)+" ad -> "+

nevsorLista.get(i+1)+" kap");

System.out.println(

nevsorLista.get(nevsorLista.size()-1)+" ad -> "+

nevsorLista.get(0)+" kap");

2. megoldás

A program átmenetileg megváltoztatja a listát: az utolsó elem után bővül az első elemmel ( nevsorLista.add(nevsorLista.get(0))). Ennek köszönhetően az ajándékot adó-kapó párosokat a listában egymás mellett lévő lévő i-edik (bal) és i+1-edik nevek adják. Most nem lesz kimaradó pár, mert a korábbi utolsó elem most az utolsó előtti elem és az utolsó elem most az első. Másképpen: mindenki ad és mindenki kap.

A megoldás Stream API-t használ. Először előállít egy olyan IntStream típusú folyamot, amiben az ajándékot adó és kapó párosok adó (bal) tagjainak sorszámát/indexét tartalmazza. Ezután ezt végigjárva összefűzi a szövegeket ( mapToObj()) úgy, hogy a páros kapó (jobb) tagja az adó tag rákövetkezője. Végül a program kiírja a összefűzött szövegeket ( forEach()) a konzolra. Ha a neveket tartalmazó listát használnánk később még valamire (azaz kellene az eredeti összekevert állapota), akkor érdemes aktiválni a megjegyzésbe tett utolsó utasítást.

System.out.println("Ajándékozás\nNévsor: "+nevsorLista);

nevsorLista.add(nevsorLista.get(0));

IntStream.range(0, nevsorLista.size()-1).

mapToObj(i -> String.format("%s ad -> %s kap",

nevsorLista.get(i), nevsorLista.get(i+1))).

forEach(System.out::println);

//nevsorLista.remove(nevsorLista.size()-1);

Eredmény

A program konzolos/szöveges eredménye mindkét esetben azonos. Persze a nevek sorrendje különbözhet, hiszen az összekeverés minden futtatás esetén másképpen alakul(hat), mert véletlenszerű. Például:

Ajándékozás

Névsor: [Károly, Anna, Máté, Péter, Zoltán, Éva, Anikó, András, Lilla, Krisztina]

Károly ad -> Anna kap

Anna ad -> Máté kap

Máté ad -> Péter kap

Péter ad -> Zoltán kap

Zoltán ad -> Éva kap

Éva ad -> Anikó kap

Anikó ad -> András kap

András ad -> Lilla kap

Lilla ad -> Krisztina kap

Krisztina ad -> Károly kap

Érdemes tesztelni és átgondolni, hogy mi történne, ha üres a fájl, üres a generikus lista, 1 név van, 2 név van, illetve nem szabadna ilyet, de mi történne azonos nevek esetén. Vajon különbözik/különbözne a fenti két megoldás eredménye? Miért?

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 17-28. óra Objektumorientált programozás és 37-44. óra: Fájlkezelés alkalmaihoz kötődik.

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.