mirror of
https://github.com/jneug/zeichenmaschine.git
synced 2026-10-12 09:56:33 +02:00
Merge branch 'main' into partikel
This commit is contained in:
34
test/res/bluej-project/BluejTest.java
Normal file
34
test/res/bluej-project/BluejTest.java
Normal file
@@ -0,0 +1,34 @@
|
||||
|
||||
import schule.ngb.zm.Zeichenmaschine;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Beschreiben Sie hier die Klasse BluejTest.
|
||||
*
|
||||
* @author (Ihr Name)
|
||||
* @version (eine Versionsnummer oder ein Datum)
|
||||
*/
|
||||
public class BluejTest extends Zeichenmaschine
|
||||
{
|
||||
public void setup() {
|
||||
if( !IN_BLUEJ ) {
|
||||
drawing.clear(schule.ngb.zm.Color.HGRED);
|
||||
} else {
|
||||
drawing.clear(schule.ngb.zm.Color.HGGREEN);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public void listClasses() {
|
||||
// find all classes in classpath
|
||||
List<String> allClasses = ClasspathInspector.getAllKnownClassNames();
|
||||
System.out.printf("There are %s classes available in the classpath\n", allClasses.size());
|
||||
|
||||
for (String clazz : allClasses) {
|
||||
if( clazz.contains("Boot") || clazz.contains("Main") ) {
|
||||
System.out.printf("%s\n", clazz);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
283
test/res/bluej-project/ClasspathInspector.java
Normal file
283
test/res/bluej-project/ClasspathInspector.java
Normal file
@@ -0,0 +1,283 @@
|
||||
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FilenameFilter;
|
||||
import java.io.Serializable;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Enumeration;
|
||||
import java.util.List;
|
||||
import java.util.jar.JarEntry;
|
||||
import java.util.jar.JarFile;
|
||||
|
||||
/**
|
||||
* Find classes in the classpath (reads JARs and classpath folders).
|
||||
*
|
||||
* @author Pål Brattberg, brattberg@gmail.com
|
||||
* @see http://gist.github.com/pal
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public class ClasspathInspector {
|
||||
static boolean DEBUG = false;
|
||||
|
||||
|
||||
public static List<String> getAllKnownClassNames() {
|
||||
List<String> classNames = new ArrayList<String>();
|
||||
List<File> classLocations = getClassLocationsForCurrentClasspath();
|
||||
for (File file : classLocations) {
|
||||
classNames.addAll(getClassNamesFromPath(file));
|
||||
}
|
||||
return classNames;
|
||||
}
|
||||
|
||||
public static List<Class> getAllKnownClasses() {
|
||||
List<Class> classFiles = new ArrayList<Class>();
|
||||
List<File> classLocations = getClassLocationsForCurrentClasspath();
|
||||
for (File file : classLocations) {
|
||||
classFiles.addAll(getClassesFromPath(file));
|
||||
}
|
||||
return classFiles;
|
||||
}
|
||||
|
||||
public static List<Class> getMatchingClasses(Class interfaceOrSuperclass) {
|
||||
List<Class> matchingClasses = new ArrayList<Class>();
|
||||
List<Class> classes = getAllKnownClasses();
|
||||
log("checking %s classes", classes.size());
|
||||
for (Class clazz : classes) {
|
||||
if (interfaceOrSuperclass.isAssignableFrom(clazz)) {
|
||||
matchingClasses.add(clazz);
|
||||
log("class %s is assignable from %s", interfaceOrSuperclass, clazz);
|
||||
}
|
||||
}
|
||||
return matchingClasses;
|
||||
}
|
||||
|
||||
public static List<Class> getMatchingClasses(String validPackagePrefix, Class interfaceOrSuperclass) {
|
||||
throw new IllegalStateException("Not yet implemented!");
|
||||
}
|
||||
|
||||
public static List<Class> getMatchingClasses(String validPackagePrefix) {
|
||||
throw new IllegalStateException("Not yet implemented!");
|
||||
}
|
||||
|
||||
private static Collection<? extends Class> getClassesFromPath(File path) {
|
||||
if (path.isDirectory()) {
|
||||
return getClassesFromDirectory(path);
|
||||
} else {
|
||||
return getClassesFromJarFile(path);
|
||||
}
|
||||
}
|
||||
|
||||
private static Collection<String> getClassNamesFromPath(File path) {
|
||||
if (path.isDirectory()) {
|
||||
return getClassNamesFromDirectory(path);
|
||||
} else {
|
||||
return getClassNamesFromJarFile(path);
|
||||
}
|
||||
}
|
||||
|
||||
private static String fromFileToClassName(final String fileName) {
|
||||
return fileName.substring(0, fileName.length() - 6).replaceAll("/|\\\\", "\\.");
|
||||
}
|
||||
|
||||
private static List<Class> getClassesFromJarFile(File path) {
|
||||
List<Class> classes = new ArrayList<Class>();
|
||||
log("getClassesFromJarFile: Getting classes for " + path);
|
||||
|
||||
try {
|
||||
if (path.canRead()) {
|
||||
JarFile jar = new JarFile(path);
|
||||
Enumeration<JarEntry> en = jar.entries();
|
||||
while (en.hasMoreElements()) {
|
||||
JarEntry entry = en.nextElement();
|
||||
if (entry.getName().endsWith("class")) {
|
||||
String className = fromFileToClassName(entry.getName());
|
||||
log("\tgetClassesFromJarFile: found " + className);
|
||||
Class claz = Class.forName(className);
|
||||
classes.add(claz);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException("Failed to read classes from jar file: " + path, e);
|
||||
}
|
||||
|
||||
return classes;
|
||||
}
|
||||
|
||||
private static List<String> getClassNamesFromJarFile(File path) {
|
||||
List<String> classes = new ArrayList<>();
|
||||
log("getClassNamesFromJarFile: Getting classes for " + path);
|
||||
|
||||
try {
|
||||
if (path.canRead()) {
|
||||
JarFile jar = new JarFile(path);
|
||||
Enumeration<JarEntry> en = jar.entries();
|
||||
while (en.hasMoreElements()) {
|
||||
JarEntry entry = en.nextElement();
|
||||
if (entry.getName().endsWith("class")) {
|
||||
String className = fromFileToClassName(entry.getName());
|
||||
classes.add(className);
|
||||
log("\tgetClassesFromJarFile: found " + className);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException("Failed to read classnames from jar file: " + path, e);
|
||||
}
|
||||
|
||||
return classes;
|
||||
}
|
||||
|
||||
private static List<Class> getClassesFromDirectory(File path) {
|
||||
List<Class> classes = new ArrayList<Class>();
|
||||
log("getClassesFromDirectory: Getting classes for " + path);
|
||||
|
||||
// get jar files from top-level directory
|
||||
List<File> jarFiles = listFiles(path, new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File dir, String name) {
|
||||
return name.endsWith(".jar");
|
||||
}
|
||||
}, false);
|
||||
for (File file : jarFiles) {
|
||||
classes.addAll(getClassesFromJarFile(file));
|
||||
}
|
||||
|
||||
// get all class-files
|
||||
List<File> classFiles = listFiles(path, new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File dir, String name) {
|
||||
return name.endsWith(".class");
|
||||
}
|
||||
}, true);
|
||||
|
||||
// List<URL> urlList = new ArrayList<URL>();
|
||||
// List<String> classNameList = new ArrayList<String>();
|
||||
int substringBeginIndex = path.getAbsolutePath().length() + 1;
|
||||
for (File classfile : classFiles) {
|
||||
String className = classfile.getAbsolutePath().substring(substringBeginIndex);
|
||||
className = fromFileToClassName(className);
|
||||
log("Found class %s in path %s: ", className, path);
|
||||
try {
|
||||
classes.add(Class.forName(className));
|
||||
} catch (Throwable e) {
|
||||
log("Couldn't create class %s. %s: ", className, e);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return classes;
|
||||
}
|
||||
|
||||
private static List<String> getClassNamesFromDirectory(File path) {
|
||||
List<String> classes = new ArrayList<>();
|
||||
log("getClassNamesFromDirectory: Getting classes for " + path);
|
||||
|
||||
// get jar files from top-level directory
|
||||
List<File> jarFiles = listFiles(path, new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File dir, String name) {
|
||||
return name.endsWith(".jar");
|
||||
}
|
||||
}, false);
|
||||
for (File file : jarFiles) {
|
||||
classes.addAll(getClassNamesFromJarFile(file));
|
||||
}
|
||||
|
||||
// get all class-files
|
||||
List<File> classFiles = listFiles(path, new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File dir, String name) {
|
||||
return name.endsWith(".class");
|
||||
}
|
||||
}, true);
|
||||
|
||||
// List<URL> urlList = new ArrayList<URL>();
|
||||
// List<String> classNameList = new ArrayList<String>();
|
||||
int substringBeginIndex = path.getAbsolutePath().length() + 1;
|
||||
for (File classfile : classFiles) {
|
||||
String className = classfile.getAbsolutePath().substring(substringBeginIndex);
|
||||
className = fromFileToClassName(className);
|
||||
log("Found class %s in path %s: ", className, path);
|
||||
classes.add(className);
|
||||
}
|
||||
|
||||
return classes;
|
||||
}
|
||||
|
||||
private static List<File> listFiles(File directory, FilenameFilter filter, boolean recurse) {
|
||||
List<File> files = new ArrayList<File>();
|
||||
File[] entries = directory.listFiles();
|
||||
|
||||
// Go over entries
|
||||
for (File entry : entries) {
|
||||
// If there is no filter or the filter accepts the
|
||||
// file / directory, add it to the list
|
||||
if (filter == null || filter.accept(directory, entry.getName())) {
|
||||
files.add(entry);
|
||||
}
|
||||
|
||||
// If the file is a directory and the recurse flag
|
||||
// is set, recurse into the directory
|
||||
if (recurse && entry.isDirectory()) {
|
||||
files.addAll(listFiles(entry, filter, recurse));
|
||||
}
|
||||
}
|
||||
|
||||
// Return collection of files
|
||||
return files;
|
||||
}
|
||||
|
||||
public static List<File> getClassLocationsForCurrentClasspath() {
|
||||
List<File> urls = new ArrayList<File>();
|
||||
String javaClassPath = System.getProperty("java.class.path");
|
||||
if (javaClassPath != null) {
|
||||
for (String path : javaClassPath.split(File.pathSeparator)) {
|
||||
urls.add(new File(path));
|
||||
}
|
||||
}
|
||||
return urls;
|
||||
}
|
||||
|
||||
// todo: this is only partial, probably
|
||||
public static URL normalize(URL url) throws MalformedURLException {
|
||||
String spec = url.getFile();
|
||||
|
||||
// get url base - remove everything after ".jar!/??" , if exists
|
||||
final int i = spec.indexOf("!/");
|
||||
if (i != -1) {
|
||||
spec = spec.substring(0, spec.indexOf("!/"));
|
||||
}
|
||||
|
||||
// uppercase windows drive
|
||||
url = new URL(url, spec);
|
||||
final String file = url.getFile();
|
||||
final int i1 = file.indexOf(':');
|
||||
if (i1 != -1) {
|
||||
String drive = file.substring(i1 - 1, 2).toUpperCase();
|
||||
url = new URL(url, file.substring(0, i1 - 1) + drive + file.substring(i1));
|
||||
}
|
||||
|
||||
return url;
|
||||
}
|
||||
|
||||
private static void log(String pattern, final Object... args) {
|
||||
if (DEBUG)
|
||||
System.out.printf(pattern + "\n", args);
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
// find all classes in classpath
|
||||
List<Class> allClasses = ClasspathInspector.getAllKnownClasses();
|
||||
System.out.printf("There are %s classes available in the classpath\n", allClasses.size());
|
||||
|
||||
// find all classes that implement/subclass an interface/superclass
|
||||
List<Class> serializableClasses = ClasspathInspector.getMatchingClasses(Serializable.class);
|
||||
for (Class clazz : serializableClasses) {
|
||||
System.out.printf("%s is Serializable\n", clazz);
|
||||
}
|
||||
}
|
||||
}
|
||||
42
test/res/bluej-project/package.bluej
Normal file
42
test/res/bluej-project/package.bluej
Normal file
@@ -0,0 +1,42 @@
|
||||
#BlueJ package file
|
||||
dependency1.from=BluejTest
|
||||
dependency1.to=ClasspathInspector
|
||||
dependency1.type=UsesDependency
|
||||
editor.fx.0.height=0
|
||||
editor.fx.0.width=0
|
||||
editor.fx.0.x=0
|
||||
editor.fx.0.y=0
|
||||
objectbench.height=94
|
||||
objectbench.width=776
|
||||
package.divider.horizontal=0.6
|
||||
package.divider.vertical=0.8305369127516778
|
||||
package.editor.height=488
|
||||
package.editor.width=661
|
||||
package.editor.x=374
|
||||
package.editor.y=158
|
||||
package.frame.height=660
|
||||
package.frame.width=800
|
||||
package.numDependencies=1
|
||||
package.numTargets=2
|
||||
package.showExtends=true
|
||||
package.showUses=true
|
||||
project.charset=UTF-8
|
||||
readme.height=60
|
||||
readme.name=@README
|
||||
readme.width=48
|
||||
readme.x=10
|
||||
readme.y=10
|
||||
target1.height=70
|
||||
target1.name=BluejTest
|
||||
target1.showInterface=false
|
||||
target1.type=ClassTarget
|
||||
target1.width=120
|
||||
target1.x=70
|
||||
target1.y=10
|
||||
target2.height=70
|
||||
target2.name=ClasspathInspector
|
||||
target2.showInterface=false
|
||||
target2.type=ClassTarget
|
||||
target2.width=130
|
||||
target2.x=380
|
||||
target2.y=30
|
||||
135
test/src/schule/ngb/zm/ColorTest.java
Normal file
135
test/src/schule/ngb/zm/ColorTest.java
Normal file
@@ -0,0 +1,135 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class ColorTest {
|
||||
|
||||
|
||||
@Test
|
||||
void testEquals() {
|
||||
Color c1 = new Color(254, 98, 12);
|
||||
Color c2 = new Color(254, 98, 12);
|
||||
assertNotSame(c1, c2);
|
||||
assertEquals(c1, c2);
|
||||
assertEquals(c1, c1);
|
||||
c2 = new Color(c1);
|
||||
assertNotSame(c1, c2);
|
||||
assertEquals(c1, c2);
|
||||
|
||||
assertEquals(Color.YELLOW, java.awt.Color.YELLOW);
|
||||
assertNotEquals(java.awt.Color.YELLOW, Color.YELLOW);
|
||||
}
|
||||
|
||||
@Test
|
||||
void construct() {
|
||||
Color c;
|
||||
// Empty color is white
|
||||
c = new Color();
|
||||
assertEquals(c, Color.BLACK);
|
||||
// One arg is shade of gray
|
||||
c = new Color(255);
|
||||
assertEquals(c, Color.WHITE);
|
||||
c = new Color(0);
|
||||
assertEquals(c, Color.BLACK);
|
||||
c = new Color(64);
|
||||
assertEquals(c, Color.DARKGRAY);
|
||||
c = new Color(192);
|
||||
assertEquals(c, Color.LIGHTGRAY);
|
||||
// RGB colors
|
||||
c = new Color(0,0,0);
|
||||
assertEquals(c, Color.BLACK);
|
||||
c = new Color(255,0,0);
|
||||
assertEquals(c, Color.RED);
|
||||
c = new Color(0,255,0);
|
||||
assertEquals(c, Color.GREEN);
|
||||
c = new Color(0,0,255);
|
||||
assertEquals(c, Color.BLUE);
|
||||
// From java.awt.Color
|
||||
c = new Color(java.awt.Color.YELLOW);
|
||||
assertEquals(c, Color.YELLOW);
|
||||
}
|
||||
|
||||
@Test
|
||||
void getRGBColor() {
|
||||
Color c1 = Color.getRGBColor(0xFFFF0000);
|
||||
assertEquals(Color.RED, c1);
|
||||
}
|
||||
|
||||
@Test
|
||||
void getHSBColor() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void getHSLColor() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void parseHexcode() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void morph() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void RGBtoHSL() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void HSLtoRGB() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testHSLtoRGB() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void copy() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void getRGBA() {
|
||||
assertEquals(java.awt.Color.YELLOW.getRGB(), Color.YELLOW.getRGBA());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getRed() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void getGreen() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void getBlue() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void getAlpha() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void getColor() {
|
||||
assertEquals(java.awt.Color.YELLOW, Color.YELLOW.getJavaColor());
|
||||
assertEquals(new java.awt.Color(255, 31, 124), new Color(255, 31, 124).getJavaColor());
|
||||
}
|
||||
|
||||
@Test
|
||||
void brighter() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testBrighter() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void darker() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDarker() {
|
||||
}
|
||||
|
||||
}
|
||||
131
test/src/schule/ngb/zm/ConstantsTest.java
Normal file
131
test/src/schule/ngb/zm/ConstantsTest.java
Normal file
@@ -0,0 +1,131 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class ConstantsTest {
|
||||
|
||||
@Test
|
||||
void min() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void max() {
|
||||
assertEquals(5.0, Constants.max(5.0, 0.0), 0.000001);
|
||||
assertEquals(5.0, Constants.max(5.0, 4.0), 0.000001);
|
||||
assertEquals(5.0, Constants.max(5.0, 5.0), 0.000001);
|
||||
assertEquals(100.0, Constants.max(100.0, -100.0), 0.000001);
|
||||
assertEquals(0.0, Constants.max(0.0, 0.0), 0.000001);
|
||||
|
||||
assertEquals(5.0, Constants.max(new double[]{ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 }), 0.000001);
|
||||
assertEquals(5.0, Constants.max(new double[]{ 5.0, 5.0, 5.0, 5.0, 5.0 }), 0.000001);
|
||||
assertEquals(5.0, Constants.max(new double[]{ 5.0 }), 0.000001);
|
||||
|
||||
assertThrows(IllegalArgumentException.class, () -> Constants.max(null));
|
||||
assertThrows(IllegalArgumentException.class, () -> Constants.max(new double[]{}));
|
||||
}
|
||||
|
||||
@Test
|
||||
void abs() {
|
||||
assertEquals(5.0, Constants.abs(5.0), 0.000001);
|
||||
assertEquals(0.0, Constants.abs(0.0), 0.000001);
|
||||
assertEquals(105.0, Constants.abs(-105.0), 0.000001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sign() {
|
||||
assertEquals(1.0, Constants.sign(5.0), 0.000001);
|
||||
assertEquals(0.0, Constants.sign(0.0), 0.000001);
|
||||
assertEquals(-1.0, Constants.sign(-105.0), 0.000001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void morph() {
|
||||
assertEquals(0.0, Constants.interpolate(0.0, 100.0, 0.0), 0.000001);
|
||||
assertEquals(10.0, Constants.interpolate(0.0, 100.0, 0.1), 0.000001);
|
||||
assertEquals(50.0, Constants.interpolate(0.0, 100.0, 0.5), 0.000001);
|
||||
assertEquals(100.0, Constants.interpolate(0.0, 100.0, 1.0), 0.000001);
|
||||
assertEquals(-100.0, Constants.interpolate(-100.0, 100.0, 0.0), 0.000001);
|
||||
assertEquals(0.0, Constants.interpolate(-100.0, 100.0, 0.5), 0.000001);
|
||||
assertEquals(100.0, Constants.interpolate(-100.0, 100.0, 1.0), 0.000001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void limit() {
|
||||
assertEquals(4, Constants.limit(4, 1, 5));
|
||||
assertEquals(1, Constants.limit(0, 1, 5));
|
||||
assertEquals(5, Constants.limit(6, 1, 5));
|
||||
assertEquals(1, Constants.limit(-6, 1, 5));
|
||||
assertEquals(-6, Constants.limit(-6, -10, 5));
|
||||
assertEquals(-10, Constants.limit(-15, -10, 5));
|
||||
assertEquals(-10, Constants.limit(-10, -10, 5));
|
||||
|
||||
assertEquals(4.0, Constants.limit(4, 1, 5), 0.000001);
|
||||
assertEquals(1.3, Constants.limit(0, 1.3, 5), 0.000001);
|
||||
assertEquals(5.0, Constants.limit(6, 1, 5), 0.000001);
|
||||
assertEquals(1.2, Constants.limit(-6, 1.2, 5), 0.000001);
|
||||
assertEquals(-6.0, Constants.limit(-6, -10, 5), 0.000001);
|
||||
assertEquals(-10.0, Constants.limit(-15, -10, 5), 0.000001);
|
||||
assertEquals(-10.3, Constants.limit(-10.3, -10.3, 5), 0.000001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void b() {
|
||||
assertTrue(Constants.getBool(true));
|
||||
assertFalse(Constants.getBool(false));
|
||||
assertTrue(Constants.getBool(1));
|
||||
assertFalse(Constants.getBool(0));
|
||||
assertTrue(Constants.getBool(4.0));
|
||||
assertFalse(Constants.getBool(0.0));
|
||||
assertTrue(Constants.getBool(4.0f));
|
||||
assertFalse(Constants.getBool(0.0f));
|
||||
assertTrue(Constants.getBool(4L));
|
||||
assertFalse(Constants.getBool(0L));
|
||||
assertTrue(Constants.getBool("true"));
|
||||
assertTrue(Constants.getBool("True"));
|
||||
assertFalse(Constants.getBool("1"));
|
||||
assertFalse(Constants.getBool("false"));
|
||||
assertFalse(Constants.getBool("yes"));
|
||||
assertFalse(Constants.getBool("no"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void randomBool() {
|
||||
float t = 0f, f = 0f;
|
||||
for( int i = 0; i < 100000; i++ ) {
|
||||
if( Constants.randomBool() ) {
|
||||
t++;
|
||||
} else {
|
||||
f++;
|
||||
}
|
||||
}
|
||||
|
||||
assertEquals(.5f, Math.abs(t/(t+f)), .01f);
|
||||
|
||||
t = 0f;
|
||||
f = 0f;
|
||||
for( int i = 0; i < 100000; i++ ) {
|
||||
if( Constants.randomBool(.2) ) {
|
||||
t++;
|
||||
} else {
|
||||
f++;
|
||||
}
|
||||
}
|
||||
|
||||
assertEquals(.2f, Math.abs(t/(t+f)), .01f);
|
||||
|
||||
t = 0f;
|
||||
f = 0f;
|
||||
for( int i = 0; i < 100000; i++ ) {
|
||||
if( Constants.randomBool(80) ) {
|
||||
t++;
|
||||
} else {
|
||||
f++;
|
||||
}
|
||||
}
|
||||
|
||||
assertEquals(.8f, Math.abs(t/(t+f)), .01f);
|
||||
}
|
||||
|
||||
}
|
||||
48
test/src/schule/ngb/zm/OptionsTest.java
Normal file
48
test/src/schule/ngb/zm/OptionsTest.java
Normal file
@@ -0,0 +1,48 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
import static schule.ngb.zm.Options.Direction.*;
|
||||
|
||||
class OptionsTest {
|
||||
|
||||
@Test
|
||||
void testDirections() {
|
||||
assertTrue(NORTH.in(NORTH));
|
||||
assertTrue(NORTH.in(NORTHEAST));
|
||||
assertTrue(EAST.in(NORTHEAST));
|
||||
assertTrue(NORTH.in(NORTHWEST));
|
||||
assertTrue(WEST.in(NORTHWEST));
|
||||
assertFalse(NORTH.in(SOUTH));
|
||||
assertFalse(NORTH.in(EAST));
|
||||
assertFalse(NORTH.in(WEST));
|
||||
assertFalse(NORTH.in(SOUTHWEST));
|
||||
assertFalse(NORTH.in(SOUTHEAST));
|
||||
|
||||
assertFalse(NORTHEAST.in(NORTH));
|
||||
assertFalse(NORTHEAST.in(SOUTH));
|
||||
assertFalse(NORTHEAST.in(NORTHWEST));
|
||||
assertTrue(NORTHEAST.in(NORTHEAST));
|
||||
|
||||
assertTrue(SOUTH.contains(SOUTH));
|
||||
assertFalse(SOUTH.contains(NORTH));
|
||||
assertFalse(SOUTH.contains(EAST));
|
||||
assertFalse(SOUTH.contains(WEST));
|
||||
assertFalse(SOUTH.contains(NORTHWEST));
|
||||
assertFalse(SOUTH.contains(SOUTHWEST));
|
||||
assertFalse(SOUTH.contains(SOUTHEAST));
|
||||
|
||||
assertTrue(SOUTHEAST.contains(SOUTH));
|
||||
assertTrue(SOUTHEAST.contains(EAST));
|
||||
assertTrue(SOUTHWEST.contains(SOUTH));
|
||||
assertTrue(SOUTHWEST.contains(WEST));
|
||||
assertFalse(SOUTHWEST.contains(NORTH));
|
||||
assertFalse(SOUTHWEST.contains(SOUTHEAST));
|
||||
assertTrue(SOUTHWEST.contains(SOUTHWEST));
|
||||
assertFalse(SOUTHWEST.contains(EAST));
|
||||
assertFalse(SOUTHWEST.contains(NORTHWEST));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,114 +1,112 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import schule.ngb.zm.formen.Form;
|
||||
import schule.ngb.zm.formen.Rechteck;
|
||||
import schule.ngb.zm.shapes.Rectangle;
|
||||
|
||||
import java.awt.*;
|
||||
import java.awt.geom.Rectangle2D;
|
||||
|
||||
public class TestAttraction extends Zeichenfenster {
|
||||
public class TestAttraction extends Zeichenmaschine {
|
||||
|
||||
public static void main(String[] args) {
|
||||
new TestAttraction();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void einstellungen() {
|
||||
public void settings() {
|
||||
setSize(800, 600);
|
||||
setTitel("My test Window");
|
||||
setTitle("My test Window");
|
||||
//setFramesPerSecond(5);
|
||||
|
||||
s2dl = new Shape2DEbene();
|
||||
hinzu(s2dl);
|
||||
s2dl = new Shape2DLayer();
|
||||
addLayer(s2dl);
|
||||
}
|
||||
|
||||
Shape2DEbene s2dl;
|
||||
Shape2DLayer s2dl;
|
||||
|
||||
Vektor posA, posB, velB, posC, velC;
|
||||
Vector posA, posB, velB, posC, velC;
|
||||
|
||||
double massA = 500, massB = 1, massC = 4.3, G = 5.0;
|
||||
|
||||
Rechteck recht;
|
||||
Rectangle recht;
|
||||
|
||||
@Override
|
||||
public void vorbereiten() {
|
||||
public void setup() {
|
||||
//zeichnung.hide();
|
||||
zeichnung.clear(200);
|
||||
posA = new Vektor(0, 0);
|
||||
posB = new Vektor(-100, -100);
|
||||
velB = new Vektor(10, -10);
|
||||
posC = new Vektor(200, 100);
|
||||
velC = new Vektor(1, 14);
|
||||
drawing.clear(200);
|
||||
posA = new Vector(0, 0);
|
||||
posB = new Vector(-100, -100);
|
||||
velB = new Vector(10, -10);
|
||||
posC = new Vector(200, 100);
|
||||
velC = new Vector(1, 14);
|
||||
|
||||
zeichnung.translate(breite /2, hoehe /2);
|
||||
zeichnung.shear(0.1, 0.5);
|
||||
drawing.translate(width /2, height /2);
|
||||
drawing.shear(0.1, 0.5);
|
||||
|
||||
recht = new Rechteck(50, 50, 150, 75);
|
||||
recht.setFuellfarbe(200);
|
||||
recht.setKonturFarbe(255, 0, 64);
|
||||
recht.setKonturDicke(2.5);
|
||||
recht.setKonturArt(Form.GESTRICHELT);
|
||||
formen.anzeigen(recht);
|
||||
recht = new Rectangle(50, 50, 150, 75);
|
||||
recht.setFillColor(200);
|
||||
recht.setStrokeColor(255, 0, 64);
|
||||
recht.setStrokeWeight(2.5);
|
||||
recht.setStrokeType(DASHED);
|
||||
shapes.add(recht);
|
||||
|
||||
zeichnung.verstecken();
|
||||
drawing.hide();
|
||||
//schule.ngb.zm.formen.verstecken();
|
||||
|
||||
s2dl.setColor(64,200,128);
|
||||
s2dl.setFillColor(64,200,128);
|
||||
s2dl.add(new Rectangle2D.Double(100, 100, 120, 80));
|
||||
}
|
||||
|
||||
public void zeichnen() {
|
||||
zeichnung.setStrokeColor(255);
|
||||
zeichnung.setStrokeWeight(4.0);
|
||||
zeichnung.setKonturArt(GESTRICHELT);
|
||||
zeichnung.clear(33, 33, 33, 100);
|
||||
public void draw() {
|
||||
drawing.setStrokeColor(255);
|
||||
drawing.setStrokeWeight(4.0);
|
||||
drawing.setStrokeType(DASHED);
|
||||
drawing.clear(33, 33, 33, 100);
|
||||
|
||||
zeichnung.setColor(Color.ORANGE);
|
||||
zeichnung.pie(posA.x, posA.y, 80, 30, 60);
|
||||
zeichnung.setColor(Color.YELLOW);
|
||||
zeichnung.circle(posA.x, posA.y, 60);
|
||||
drawing.setFillColor(Color.ORANGE);
|
||||
drawing.pie(posA.x, posA.y, 80, 30, 60);
|
||||
drawing.setFillColor(Color.YELLOW);
|
||||
drawing.circle(posA.x, posA.y, 60);
|
||||
|
||||
Vektor acc = acceleration(posA, posB, massA, massB);
|
||||
velB.addieren(acc);
|
||||
posB.addieren(velB);
|
||||
Vector acc = acceleration(posA, posB, massA, massB);
|
||||
velB.add(acc);
|
||||
posB.add(velB);
|
||||
|
||||
zeichnung.setColor(Color.BLUE);
|
||||
zeichnung.circle(posB.x, posB.y, 20);
|
||||
drawing.setFillColor(Color.BLUE);
|
||||
drawing.circle(posB.x, posB.y, 20);
|
||||
|
||||
acc = acceleration(posA, posC, massA, massC);
|
||||
velC.addieren(acc);
|
||||
posC.addieren(velC);
|
||||
velC.add(acc);
|
||||
posC.add(velC);
|
||||
|
||||
zeichnung.setColor(Color.GREEN);
|
||||
zeichnung.circle(posC.x, posC.y, 20);
|
||||
drawing.setFillColor(Color.GREEN);
|
||||
drawing.circle(posC.x, posC.y, 20);
|
||||
|
||||
zeichnung.rotate(1);
|
||||
drawing.rotate(1);
|
||||
|
||||
formen.leeren();
|
||||
shapes.clear();
|
||||
double x = recht.getX();
|
||||
x = (x+100*delta)% breite;
|
||||
x = (x+100*delta)% width;
|
||||
recht.setX(x);
|
||||
}
|
||||
|
||||
Vektor acceleration(Vektor a, Vektor b, double ma, double mb ) {
|
||||
Vektor acc = Vektor.subtrahieren(a, b);
|
||||
double draw = (G*ma*mb)/acc.laengeQuad();
|
||||
acc.setLaenge(draw*delta);
|
||||
acc.beschraenken(3, 30);
|
||||
Vector acceleration( Vector a, Vector b, double ma, double mb ) {
|
||||
Vector acc = Vector.sub(a, b);
|
||||
double draw = (G*ma*mb)/acc.lengthSq();
|
||||
acc.setLength(draw*delta);
|
||||
acc.limit(3, 30);
|
||||
return acc;
|
||||
}
|
||||
|
||||
public void mouseDragged() {
|
||||
zeichnung.translate(mausX - lmausX, mausY - lmausY);
|
||||
drawing.translate(mouseX - pmouseX, mouseY - pmouseY);
|
||||
}
|
||||
|
||||
boolean zoom = true;
|
||||
public void mouseClicked() {
|
||||
//canvas.translateToCanvas(mouseX-width/2.0, mouseY-height/2.0);
|
||||
if( zoom ) {
|
||||
zeichnung.scale(2.0);
|
||||
drawing.scale(2.0);
|
||||
} else {
|
||||
zeichnung.scale(.5);
|
||||
drawing.scale(.5);
|
||||
}
|
||||
zoom = !zoom;
|
||||
}
|
||||
|
||||
145
test/src/schule/ngb/zm/TestColor.java
Normal file
145
test/src/schule/ngb/zm/TestColor.java
Normal file
@@ -0,0 +1,145 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class TestColor {
|
||||
|
||||
@Test
|
||||
public void colors() {
|
||||
Color c;
|
||||
|
||||
c = new Color();
|
||||
assertEquals(0, c.getRed());
|
||||
assertEquals(0, c.getGreen());
|
||||
assertEquals(0, c.getBlue());
|
||||
assertEquals(255, c.getAlpha());
|
||||
|
||||
c = Color.BLUE;
|
||||
assertEquals(0, c.getRed());
|
||||
assertEquals(0, c.getGreen());
|
||||
assertEquals(255, c.getBlue());
|
||||
assertEquals(255, c.getAlpha());
|
||||
|
||||
c = new Color(50, 133, 64, 33);
|
||||
assertEquals(50, c.getRed());
|
||||
assertEquals(133, c.getGreen());
|
||||
assertEquals(64, c.getBlue());
|
||||
assertEquals(33, c.getAlpha());
|
||||
|
||||
c = new Color(255, 0, 0);
|
||||
assertEquals(Color.RED, c);
|
||||
|
||||
c = new Color(33, 50);
|
||||
assertEquals(33, c.getRed());
|
||||
assertEquals(33, c.getGreen());
|
||||
assertEquals(33, c.getBlue());
|
||||
assertEquals(50, c.getAlpha());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseColors() {
|
||||
Color c;
|
||||
|
||||
c = Color.getRGBColor(0x00FF00FF);
|
||||
assertEquals(0x00FF00FF, c.getRGBA());
|
||||
assertEquals(255, c.getRed());
|
||||
assertEquals(0, c.getGreen());
|
||||
assertEquals(255, c.getBlue());
|
||||
assertEquals(0, c.getAlpha());
|
||||
|
||||
c = Color.getRGBColor(0x33FF3333);
|
||||
assertEquals(0x33FF3333, c.getRGBA());
|
||||
assertEquals(255, c.getRed());
|
||||
assertEquals(51, c.getGreen());
|
||||
assertEquals(51, c.getBlue());
|
||||
assertEquals(51, c.getAlpha());
|
||||
|
||||
c = Color.parseHexcode("FF00FF");
|
||||
assertEquals(0xFFFF00FF, c.getRGBA());
|
||||
assertEquals(255, c.getRed());
|
||||
assertEquals(0, c.getGreen());
|
||||
assertEquals(255, c.getBlue());
|
||||
assertEquals(255, c.getAlpha());
|
||||
|
||||
c = Color.parseHexcode("#FF00FF00");
|
||||
assertEquals(0x00FF00FF, c.getRGBA());
|
||||
assertEquals(255, c.getRed());
|
||||
assertEquals(0, c.getGreen());
|
||||
assertEquals(255, c.getBlue());
|
||||
assertEquals(0, c.getAlpha());
|
||||
|
||||
c = Color.parseHexcode("#333");
|
||||
assertEquals(0xFF333333, c.getRGBA());
|
||||
assertEquals(51, c.getRed());
|
||||
assertEquals(51, c.getGreen());
|
||||
assertEquals(51, c.getBlue());
|
||||
assertEquals(255, c.getAlpha());
|
||||
|
||||
c = Color.parseHexcode("#33FF0033");
|
||||
assertEquals(0x3333FF00, c.getRGBA());
|
||||
assertEquals(51, c.getRed());
|
||||
assertEquals(255, c.getGreen());
|
||||
assertEquals(0, c.getBlue());
|
||||
assertEquals(51, c.getAlpha());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hsl() {
|
||||
Color c;
|
||||
float[] hsl;
|
||||
|
||||
c = Color.RED;
|
||||
hsl = Color.RGBtoHSL(c.getRGBA(), null);
|
||||
assertArrayEquals(new float[]{0f,1f,.5f}, hsl, 0.0001f);
|
||||
|
||||
c = new Color(255, 33, 64);
|
||||
hsl = Color.RGBtoHSL(c.getRGBA(), null);
|
||||
assertEquals(352, hsl[0], 1.0f);
|
||||
assertEquals(1.0f, hsl[1], .0001f);
|
||||
assertEquals(.5647f, hsl[2], .0001f);
|
||||
}
|
||||
|
||||
public static void main( String[] args ) {
|
||||
new ColorPalette();
|
||||
}
|
||||
|
||||
static class ColorPalette extends Zeichenmaschine {
|
||||
public static final int SIZE = 10, COLORS = 16;
|
||||
|
||||
public void setup() {
|
||||
setSize(SIZE*COLORS, SIZE*COLORS);
|
||||
setTitle("Colors");
|
||||
|
||||
drawing.noStroke();
|
||||
drawing.setAnchor(NORTHWEST);
|
||||
|
||||
int steps = (int) (255.0/COLORS);
|
||||
Color c;
|
||||
for( int i = 0; i < COLORS; i++ ) {
|
||||
for( int j = 0; j < COLORS; j++ ) {
|
||||
c = new Color(i * steps, j * steps, (i+j)/2 * steps);
|
||||
drawing.setFillColor(c);
|
||||
drawing.rect(i*SIZE, j*SIZE, SIZE, SIZE);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
Color c = Color.HGGREEN;
|
||||
drawing.setFillColor(c);
|
||||
drawing.rect(0, 0, width/2, height);
|
||||
|
||||
for( int p = 10; p < 100; p += 10 ) {
|
||||
drawing.setFillColor(c.brighter(p));
|
||||
drawing.rect(width / 2, 0, width / 2, height / 2);
|
||||
drawing.setFillColor(c.darker(p));
|
||||
drawing.rect(width / 2, height / 2, width / 2, height / 2);
|
||||
|
||||
delay(1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
71
test/src/schule/ngb/zm/TestDrawing.java
Normal file
71
test/src/schule/ngb/zm/TestDrawing.java
Normal file
@@ -0,0 +1,71 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
public class TestDrawing extends Zeichenmaschine {
|
||||
|
||||
private final double w = 100, h = 50;
|
||||
|
||||
private double xa = 50, ya = 50;
|
||||
|
||||
private double x2 = 200, y2 = 50;
|
||||
|
||||
int frames = 0;
|
||||
long start = 0;
|
||||
|
||||
public static void main( String[] args ) {
|
||||
new TestDrawing();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setup() {
|
||||
drawing.setFont("AvenirNext-Medium", 14);
|
||||
drawing.setAnchor(NORTHWEST);
|
||||
|
||||
start = System.currentTimeMillis();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void update( double delta ) {
|
||||
ya = (ya+1)%350;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void draw() {
|
||||
long ms = System.currentTimeMillis();
|
||||
|
||||
drawing.clear();
|
||||
|
||||
// x2 = mouseX;
|
||||
// y2 = mouseY;
|
||||
|
||||
drawing.resetStroke();
|
||||
drawing.rect(xa, ya, w, h);
|
||||
|
||||
//drawing.image("WitchCraftIcons_122_t.PNG", width/2, height/2, .5, CENTER);
|
||||
|
||||
for( int i = 0; i < 4; i++ ) {
|
||||
//delay(1000);
|
||||
drawing.resetStroke();
|
||||
drawing.rect(x2 + i*10, y2 + i * 75, w, h);
|
||||
connect(xa + w, ya + h / 2.0, x2 + i*10, y2 + i * 75 + h / 2.0);
|
||||
drawing.text("Rect " + i, x2 + i*10 + w / 2.0, y2 + i * 75 + h / 2.0, CENTER);
|
||||
}
|
||||
|
||||
|
||||
if( (System.currentTimeMillis()-start) >= 1000 ) {
|
||||
System.out.printf("FPS: %d\n", frames);
|
||||
frames = 0;
|
||||
start = System.currentTimeMillis();
|
||||
} else {
|
||||
frames += 1;
|
||||
}
|
||||
}
|
||||
|
||||
private void connect( double x1, double y1, double x2, double y2 ) {
|
||||
double midx = (x1 + x2) / 2.0;
|
||||
drawing.setStrokeType(DASHED);
|
||||
drawing.setStrokeWeight(2.4);
|
||||
drawing.curve(x1, y1, midx, y1, midx, y2, x2, y2);
|
||||
//drawing.curve(x1, y1, x2, y1, x1, y2, x2, y2);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import schule.ngb.zm.formen.*;
|
||||
|
||||
import java.awt.*;
|
||||
import java.awt.geom.Point2D;
|
||||
import java.util.Random;
|
||||
|
||||
public class TestFormen extends Zeichenfenster {
|
||||
public static void main( String[] args ) {
|
||||
new TestFormen();
|
||||
}
|
||||
|
||||
|
||||
Kurve k;
|
||||
|
||||
@Override
|
||||
public void vorbereiten() {
|
||||
setSize(400, 400);
|
||||
|
||||
k = new Kurve(50, 50, 100, 50, 100, 100,150, 100);
|
||||
//formen.anzeigen(new Kurve(50, 50, 100, 50, 150, 100));
|
||||
formen.anzeigen(k);
|
||||
|
||||
k.verschiebeNach(200, 200);
|
||||
k.skalieren(1.1);
|
||||
|
||||
showDot(k.getStartpunkt());
|
||||
showDot(k.getKontrollpunkt1());
|
||||
showDot(k.getKontrollpunkt2());
|
||||
showDot(k.getEndpunkt());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void aktualisieren( double delta ) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void zeichnen() {
|
||||
formen.leeren();
|
||||
}
|
||||
|
||||
private void showDot( Point2D p ) {
|
||||
showDot(p.getX(), p.getY(), randomColor());
|
||||
}
|
||||
private void showDot( double x, double y, Color clr ) {
|
||||
Punkt p = new Punkt(x, y);
|
||||
p.setFuellfarbe(clr);
|
||||
p.setKonturFarbe(clr);
|
||||
formen.anzeigen(p);
|
||||
}
|
||||
|
||||
Random rand = new Random();
|
||||
|
||||
private Color randomColor() {
|
||||
return new Color(
|
||||
rand.nextInt(256),
|
||||
rand.nextInt(256),
|
||||
rand.nextInt(256),
|
||||
128
|
||||
);
|
||||
}
|
||||
|
||||
}
|
||||
46
test/src/schule/ngb/zm/TestInput.java
Normal file
46
test/src/schule/ngb/zm/TestInput.java
Normal file
@@ -0,0 +1,46 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import schule.ngb.zm.shapes.*;
|
||||
|
||||
import java.awt.geom.Point2D;
|
||||
|
||||
public class TestInput extends Zeichenmaschine {
|
||||
|
||||
public static void main( String[] args ) {
|
||||
new TestInput();
|
||||
}
|
||||
|
||||
private Text text;
|
||||
|
||||
@Override
|
||||
public void setup() {
|
||||
|
||||
//setFramesPerSecond(5);
|
||||
shapes.add(new Point(200, 200));
|
||||
shapes.add(new Point(200, 200));
|
||||
|
||||
shapes.getShape(0).setFillColor(GREEN);
|
||||
shapes.getShape(1).setFillColor(PINK);
|
||||
|
||||
text = new Text(10, 42, "");
|
||||
text.setFontsize(32);
|
||||
text.setAnchor(NORTHWEST);
|
||||
shapes.add(text);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void update( double delta ) {
|
||||
shapes.getShape(0).moveTo(mouseX, mouseY);
|
||||
shapes.getShape(1).moveTo(pmouseX, pmouseY);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void draw() {
|
||||
drawing.line(pmouseX, pmouseY, mouseX, mouseY);
|
||||
}
|
||||
|
||||
public void keyPressed() {
|
||||
text.setText(""+key);
|
||||
}
|
||||
|
||||
}
|
||||
110
test/src/schule/ngb/zm/TestShapes.java
Normal file
110
test/src/schule/ngb/zm/TestShapes.java
Normal file
@@ -0,0 +1,110 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import schule.ngb.zm.shapes.*;
|
||||
import schule.ngb.zm.shapes.Point;
|
||||
import schule.ngb.zm.shapes.Polygon;
|
||||
import schule.ngb.zm.shapes.Rectangle;
|
||||
import schule.ngb.zm.shapes.Shape;
|
||||
|
||||
import java.awt.geom.Point2D;
|
||||
import java.util.Random;
|
||||
|
||||
public class TestShapes extends Zeichenmaschine {
|
||||
|
||||
public static void main( String[] args ) {
|
||||
new TestShapes();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setup() {
|
||||
setSize(400, 400);
|
||||
|
||||
//createShapes();
|
||||
|
||||
//add(new Triangle(200, 150, 150, 250, 250, 250));
|
||||
add(new Rectangle(200, 200, 200, 100));
|
||||
shapes.getShape(0).setAnchor(CENTER);
|
||||
}
|
||||
|
||||
public void createShapes() {
|
||||
add(new Rectangle(20, 10, 40, 20));
|
||||
add(new Ellipse(40, 50, 40, 20));
|
||||
add(new Circle(40, 80, 10));
|
||||
|
||||
add(new Line(40, 100, 100, 40));
|
||||
add(new Arrow(200, 200, 105, 45));
|
||||
|
||||
shapes.add(new Point(200, 200));
|
||||
|
||||
add(new Rhombus(40, 200, 50, 120));
|
||||
add(new Kite(40, 200, 50, 120, .75));
|
||||
add(new Kite(40, 200, 50, 120, .25));
|
||||
|
||||
add(new RoundedRectangle(20, 300, 100, 60, 30));
|
||||
|
||||
add(new Arc(200, 200, 60, 90, 120));
|
||||
|
||||
add(new Polygon(250, 40, 300, 55, 321, 83, 200, 300));
|
||||
shapes.add(new Point(250, 40));
|
||||
shapes.add(new Point(300, 55));
|
||||
shapes.add(new Point(321, 83));
|
||||
shapes.add(new Point(200, 300));
|
||||
|
||||
add(new Triangle(300, 55, 355, 75, 345, 25));
|
||||
add(new Quad(300, 55, 355, 75, 345, 25, 300, 10));
|
||||
|
||||
add(new Curve(50, 50, 350, 50, 350, 350));
|
||||
add(new Curve(50, 50, 50, 350, 350, 50, 350, 350));
|
||||
|
||||
shapes.add(new Picture(300, 300, "WitchCraftIcons_122_t.PNG"));
|
||||
|
||||
add(new Text(200, 40, "Shapes 😊"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void update( double delta ) {
|
||||
//shapes.getShape(Triangle.class).rotate(2);
|
||||
shapes.getShape(0).rotate(200, 250,2);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void mouseClicked() {
|
||||
for( Shape s : shapes.getShapes() ) {
|
||||
randomizeShape(s);
|
||||
//s.move(10, 10);
|
||||
}
|
||||
}
|
||||
|
||||
private void add( Shape s ) {
|
||||
shapes.add(randomizeShape(s));
|
||||
}
|
||||
|
||||
private Shape randomizeShape( Shape s ) {
|
||||
if( !(s instanceof Arc) && !(s instanceof Curve) && !(s instanceof Line) && !(s instanceof Arrow) ) {
|
||||
s.setFillColor(randomColor());
|
||||
}
|
||||
s.setStrokeColor(randomColor());
|
||||
s.setStrokeWeight(random(.75, 2.25));
|
||||
if( randomBool(20) ) {
|
||||
s.setStrokeType(DASHED);
|
||||
} else {
|
||||
s.setStrokeType(SOLID);
|
||||
}
|
||||
|
||||
//s.moveTo(random(20, 380), random(20, 380));
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
private void showDot( Point2D p ) {
|
||||
showDot(p.getX(), p.getY(), randomColor());
|
||||
}
|
||||
|
||||
private void showDot( double x, double y, Color clr ) {
|
||||
Point p = new Point(x, y);
|
||||
p.setFillColor(clr);
|
||||
p.setStrokeColor(clr);
|
||||
shapes.add(p);
|
||||
}
|
||||
|
||||
}
|
||||
78
test/src/schule/ngb/zm/TestTurtle.java
Normal file
78
test/src/schule/ngb/zm/TestTurtle.java
Normal file
@@ -0,0 +1,78 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import schule.ngb.zm.turtle.TurtleLayer;
|
||||
import schule.ngb.zm.turtle.TurtleLayer.Turtle;
|
||||
|
||||
public class TestTurtle extends Zeichenmaschine {
|
||||
|
||||
public static void main( String[] args ) {
|
||||
new TestTurtle();
|
||||
}
|
||||
|
||||
TurtleLayer turtle;
|
||||
|
||||
TurtleLayer.Turtle t1, t2;
|
||||
|
||||
public void setup() {
|
||||
turtle = new TurtleLayer();
|
||||
addLayer(turtle);
|
||||
|
||||
t1 = turtle.getTurtle();
|
||||
t2 = turtle.newTurtle();
|
||||
|
||||
t1.setStrokeWeight(2.0);
|
||||
t2.setStrokeWeight(1.4);
|
||||
|
||||
t1.setFillColor(244, 64, 22);
|
||||
t2.setFillColor(33, 64, 255);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void update( double delta ) {
|
||||
//t1.right(1);
|
||||
t1.penUp();
|
||||
t1.moveTo(100, 100);
|
||||
t1.penDown();
|
||||
|
||||
t2.penUp();
|
||||
t2.moveTo(200, 200);
|
||||
t2.penDown();
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
turtle.clear();
|
||||
star(5, 80, 40, t1);
|
||||
star(5, 80, 40, t2);
|
||||
}
|
||||
|
||||
void star( int corners, int size ) {
|
||||
star(5, size, 40, t1);
|
||||
}
|
||||
|
||||
void star( int corners, int size, int angle, Turtle t ) {
|
||||
int angle2 = (180 - (360/corners) - angle) / 2;
|
||||
|
||||
t.penUp();
|
||||
t.left();
|
||||
t.fd(size*1.25);
|
||||
t.right();
|
||||
t.penDown();
|
||||
|
||||
for( int i = 0; i < corners; i++ ) {
|
||||
t.right(360/corners);
|
||||
t.right(angle2);
|
||||
t.fd(size);
|
||||
t.left(2*angle2);
|
||||
t.fd(size);
|
||||
t.right(angle2);
|
||||
}
|
||||
t.fill();
|
||||
|
||||
t.penUp();
|
||||
t.right();
|
||||
t.fd(size*1.25);
|
||||
t.left();
|
||||
t.penDown();
|
||||
}
|
||||
|
||||
}
|
||||
112
test/src/schule/ngb/zm/TestVector.java
Normal file
112
test/src/schule/ngb/zm/TestVector.java
Normal file
@@ -0,0 +1,112 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.awt.geom.Point2D;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class TestVector {
|
||||
|
||||
@Test
|
||||
public void testInit() {
|
||||
Vector vec;
|
||||
|
||||
vec = new Vector();
|
||||
assertEquals(0.0, vec.x, 0.0);
|
||||
assertEquals(0.0, vec.y, 0.0);
|
||||
|
||||
vec = new Vector(4.5, 5.1);
|
||||
assertEquals(4.5, vec.x, 0.0);
|
||||
assertEquals(5.1, vec.y, 0.0);
|
||||
|
||||
vec = new Vector(vec);
|
||||
assertEquals(4.5, vec.x, 0.0);
|
||||
assertEquals(5.1, vec.y, 0.0);
|
||||
|
||||
vec = new Vector(Double.MAX_VALUE, Double.MIN_VALUE);
|
||||
assertEquals(Double.MAX_VALUE, vec.x, 0.0);
|
||||
assertEquals(Double.MIN_VALUE, vec.y, 0.0);
|
||||
|
||||
vec = new Vector(new Point2D.Double(7.2, 3.5677));
|
||||
assertEquals(7.2, vec.x, 0.0);
|
||||
assertEquals(3.5677, vec.y, 0.0);
|
||||
|
||||
vec = new Vector(new Point2D.Float(7.2f, 3.5677f));
|
||||
assertEquals(7.2, vec.x, 0.0001);
|
||||
assertEquals(3.5677, vec.y, 0.0001);
|
||||
|
||||
vec.set(new Vector(5.1, 8.9));
|
||||
assertEquals(5.1, vec.x, 0.0001);
|
||||
assertEquals(8.9, vec.y, 0.0001);
|
||||
|
||||
Vector vec2 = vec.copy();
|
||||
assertNotSame(vec, vec2);
|
||||
assertEquals(vec, vec2);
|
||||
assertEquals(5.1, vec2.x, 0.0001);
|
||||
assertEquals(8.9, vec2.y, 0.0001);
|
||||
|
||||
assertEquals(vec, vec.set(100, 100));
|
||||
assertEquals(200, vec.set(200, 200).x, 0.0001);
|
||||
assertEquals(8.9, vec.set(vec2).y, 0.0001);
|
||||
|
||||
for( int i = 0; i < 50; i++ ) {
|
||||
vec = Vector.random();
|
||||
assertTrue(vec.x >= 0);
|
||||
assertTrue(vec.y >= 0);
|
||||
assertTrue(vec.x < 100);
|
||||
assertTrue(vec.y < 100);
|
||||
}
|
||||
|
||||
for( int i = 1; i < 50; i++ ) {
|
||||
vec = Vector.random(0, i*10);
|
||||
assertTrue(vec.x >= 0);
|
||||
assertTrue(vec.y >= 0);
|
||||
assertTrue(vec.x < i*10);
|
||||
assertTrue(vec.y < i*10);
|
||||
}
|
||||
|
||||
for( int i = 1; i < 50; i++ ) {
|
||||
vec = Vector.random(0, i*10, (i+1)*10, (i+2)*10);
|
||||
assertTrue(vec.x >= 0);
|
||||
assertTrue(vec.y >= (i+1)*10);
|
||||
assertTrue(vec.x < i*10);
|
||||
assertTrue(vec.y < (i+2)*10);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMath() {
|
||||
Vector vec1, vec2;
|
||||
|
||||
vec1 = new Vector(100, 0);
|
||||
vec1.scale(0.0);
|
||||
vec2 = new Vector(0, 0);
|
||||
assertEquals(vec2, vec1);
|
||||
|
||||
vec1.add(100, 50);
|
||||
assertEquals(100, vec1.x, 0.0);
|
||||
assertEquals(50, vec1.y, 0.0);
|
||||
|
||||
vec2.sub(50, 100);
|
||||
assertEquals(-50, vec2.x, 0.0);
|
||||
assertEquals(-100, vec2.y, 0.0);
|
||||
|
||||
vec2.scale(1.5);
|
||||
assertEquals(-75, vec2.x, 0.0001);
|
||||
assertEquals(-150, vec2.y, 0.0001);
|
||||
|
||||
assertEquals(100, vec1.set(100,0).length(), 0.0001);
|
||||
assertEquals(10000, vec1.lengthSq(), 0.0001);
|
||||
assertEquals(Math.sqrt(50*50 + 60*60), vec1.set(50,60).length(), 0.0001);
|
||||
assertEquals(1.0, vec1.set(100,0).normalize().length(), 0.0001);
|
||||
assertEquals(1.0, Vector.random().normalize().length(), 0.0001);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testStaticMath() {
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
192
test/src/schule/ngb/zm/VectorTest.java
Normal file
192
test/src/schule/ngb/zm/VectorTest.java
Normal file
@@ -0,0 +1,192 @@
|
||||
package schule.ngb.zm;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class VectorTest {
|
||||
|
||||
@Test
|
||||
void setLength() {
|
||||
Vector vec = new Vector(2.0, 5.4);
|
||||
Vector vec2 = Vector.setLength(vec, 10);
|
||||
assertEquals(10.0, vec2.length(), 0.00001);
|
||||
Vector vec3 = Vector.setLength(vec, -10);
|
||||
assertEquals(10.0, vec3.length(), 0.00001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void normalize() {
|
||||
Vector vec = new Vector(4.0, 3.0);
|
||||
assertEquals(5.0, vec.length(), 0.00001);
|
||||
Vector vec2 = vec.normalize();
|
||||
assertSame(vec, vec2);
|
||||
assertEquals(1.0, vec.length(), 0.00001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void add() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void sub() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void scale() {
|
||||
Vector vec = new Vector(4.0, 3.0);
|
||||
assertEquals(5.0, vec.length(), 0.00001);
|
||||
Vector vec2 = vec.scale(10.0);
|
||||
assertSame(vec, vec2);
|
||||
assertEquals(50.0, vec.length(), 0.00001);
|
||||
vec2.scale(-10.0);
|
||||
assertEquals(500.0, vec.length(), 0.00001);
|
||||
assertEquals(-400.0, vec.x, 0.00001);
|
||||
assertEquals(-300.0, vec.y, 0.00001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void div() {
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
void dist() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void dot() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void cross() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void rotate() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void morph() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void copy() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void set() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSet() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSet1() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void setX() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void setY() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void getPunkt() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void len() {
|
||||
Vector vec = new Vector(4.0, 3.0);
|
||||
assertEquals(5.0, vec.length(), 0.00001);
|
||||
vec = new Vector(1.0, 0.0);
|
||||
assertEquals(1.0, vec.length(), 0.00001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void lenSq() {
|
||||
Vector vec = new Vector(4.0, 3.0);
|
||||
assertEquals(25.0, vec.lengthSq(), 0.00001);
|
||||
vec = new Vector(1.0, 0.0);
|
||||
assertEquals(1.0, vec.lengthSq(), 0.00001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void setLen() {
|
||||
Vector vec = new Vector(2.0, 5.4);
|
||||
Vector vec2 = vec.setLength(10);
|
||||
assertEquals(10.0, vec.length(), 0.00001);
|
||||
assertSame(vec, vec2);
|
||||
vec.setLength(-10);
|
||||
assertEquals(10.0, vec.length(), 0.00001);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNormalize() {
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAdd() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAdd1() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSub() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSub1() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testScale() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDiv() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDist() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDot() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDot1() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCross() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void limit() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLimit() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void angle() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testRotate() {
|
||||
}
|
||||
|
||||
@Test
|
||||
void testMorph() {
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user