/* Copyright (C) 2014 A.Vontobel
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The license is in LICENCE-GPL.txt.
* If not, see http://www.gnu.org/licenses/old-licenses/gpl-2.0.html.
*/
package net.sf.drawj2d.cmd.statics;
import net.sf.drawj2d.cmd.Fkt;
import no.geosoft.cc.geometry.Geometry;
/**
*
* @author av
*/
public class clKraft {
public static boolean debug = false;
/** GESPERRT blockiert das öffentliche Setzten der Kraft. Nötig, damit
in der abgeleiteten Klasse clResultierende die Resultierende nicht
überschrieben werden kann.*/
protected boolean GESPERRT = false;
protected boolean ZUERSTBERECHNEN = true;
/** Eine nachträglich geänderte Kraft wird markiert. Damit weiss eine abhängige Resultierende,
* dass sie neu berechnen muss. Zurzeit wird HATGEÄNDERT nie zurückgesetzt. */ // TODO
protected boolean HATGEÄNDERT = false;
private double Fx;
private double Fy;
private double x0; // Angriffspunkt
private double y0;
/** Kreiert eine neue Kraft. */
public clKraft(double Fx, double Fy, double x0, double y0) {
setKraftIntern(Fx, Fy, x0, y0);
}
/** Kreiert eine leere Kraft. */
public clKraft() {
setKraftIntern(0, 0, 0, 0);
}
/** Setzt die Kraft, nur für den programminternen Gebrauch.
Nötigenfalls HATGEÄNDERT = true; setzen, falls bereits eine Resultierende von der Kraft abhängen könnte.*/
protected void setKraftIntern(double Fx, double Fy, double x0, double y0) {
this.Fx = Fx;
this.Fy = Fy;
this.x0 = x0;
this.y0 = y0;
}
/** Setzt (überschreibt) die Kraft, inkl.Angriffspunkt.*/
public void setKraft(double Fx, double Fy, double x0, double y0) {
if (GESPERRT) {
System.err.println("[clKraft] Fehler: die Kraft darf nicht ueberschrieben werden!");
assert false;
}
else {
setKraftIntern(Fx, Fy, x0, y0);
HATGEÄNDERT = true;
ZUERSTBERECHNEN = true;
}
}
/** Setzt (überschreibt) die Kraft.*/
public void setKraft(double Fx, double Fy) {
if (GESPERRT) {
System.err.println("[clKraft] Fehler: die Kraft darf nicht ueberschrieben werden!");
assert false;
}
else {
this.Fx = Fx;
this.Fy = Fy;
HATGEÄNDERT = true;
ZUERSTBERECHNEN = true;
}
}
/** Setzt (überschreibt) den Angriffspunkt der Kraft.*/
public void setPkt(double x0, double y0) {
if (GESPERRT) {
System.err.println("[clKraft] Fehler: die Kraft darf nicht ueberschrieben werden!");
assert false;
}
else {
this.x0 = x0;
this.y0 = y0;
HATGEÄNDERT = true;
ZUERSTBERECHNEN = true;
}
}
/** Gibt die Kraftkomponenten an.*/
public double[] F() {
if (ZUERSTBERECHNEN) berechnen();
double[] F = {Fx, Fy};
return F;
}
/** Gibt den Absolutwert der Kraft an. Es gilt f >= 0.*/
public double f() {
if (ZUERSTBERECHNEN) berechnen();
return Math.sqrt(Fx*Fx + Fy*Fy);
}
/** Angriffspkt*/
public double[] pkt() {
if (ZUERSTBERECHNEN) berechnen();
double[] pkt = {x0, y0};
return pkt;
}
/** Diese Methode soll tut in clKraft nichts. Sie kann in abgeleiteten Klassen
überschrieben werden. Ist ZUERSTBERECHNEN gesetzt, wird die Methode aufgerufen,
* bevor ein Resultat bekanntgegeben werden soll.*/
protected boolean berechnen() {
ZUERSTBERECHNEN = false;
return true;
}
/** Verschiebt die Kraft entlang der Wirkungslinie bis zum Schnittpkt mit der Linie A-B.
@return false bei zur Wirkungslinie parallelen Linie. */
public boolean setAngriffspktAufLinie(double[] pktA, double[] pktB) {
if (ZUERSTBERECHNEN) berechnen();
boolean schneidensich = false;
double[] schnittpunkt = new double[2];
schneidensich = getAngriffspktAufLinie(pktA, pktB, schnittpunkt);
if (schneidensich) {
x0 = schnittpunkt[0];
y0 = schnittpunkt[1];
}
return schneidensich;
}
/** Gibt den Schnittpunkt der Wirkungslinie der Kraft mit einer beliebigen (nicht parallelen) Linie an.
@return false bei zur Wirkungslinie parallelen Linie. */
public boolean getAngriffspktAufLinie(double[] pktA, double[] pktB, double[] schnittpunkt) {
assert schnittpunkt.length == 2;
return getAngriffspktAufLinie(pktA[0], pktA[1], pktB[0], pktB[1], schnittpunkt);
}
/** Gibt den Schnittpunkt der Wirkungslinie der Kraft mit einer beliebigen (nicht parallelen) Linie an.
@return false bei zur Wirkungslinie parallelen Linie. */
public boolean getAngriffspktAufLinie(double x1, double y1, double x2, double y2, double[] schnittpunkt) {
assert schnittpunkt.length == 2;
if (ZUERSTBERECHNEN) berechnen();
boolean ok = false;
double[] intersection = new double[2];
int fall = Geometry.findLineSegmentIntersection(x0, y0, x0+Fx, y0+Fy, x1, y1, x2, y2, intersection);
switch (fall) {
case 1: // Linienabschnitte schneiden sich
case 0: // Verlängerung der Abschnitte schneiden sich (i.O).
ok = true;
break;
case -2: // Linien liegen aufeinander
intersection[0] = x0; // gibt den bekannten Kraftangriffspunkt zurück
intersection[1] = y0;
if (debug) System.out.println("[clKraft] Hinweis: Linien aufeinanderliegend");
ok = true;
break;
case -1: // Linien parallel
default:
if (debug) System.out.println("clKraft: Kein Schnittpunkt, da Linien parallel");
intersection[0] = x0; // gibt den bekannten Kraftangriffspunkt zurück
intersection[1] = y0;
ok = false;
}
schnittpunkt[0] = intersection[0];
schnittpunkt[1] = intersection[1];
return ok;
}
/** gibt das Moment aus der Kraft bezüglich eines Bezugspunktes an */
public double getM(double[] bezugspunkt) {
assert bezugspunkt.length == 2;
if (ZUERSTBERECHNEN) berechnen();
double dx = x0 - bezugspunkt[0];
double dy = y0 - bezugspunkt[1];
double M = dx * Fy - dy * Fx;
return M;
}
/** Schreibt die Angaben zur Kraft auf stdout.*/
public void print() {
System.out.println(text());
}
/** Angaben zur Kraft. */
public String text() {
if (ZUERSTBERECHNEN) berechnen();
StringBuilder sb = new StringBuilder();
sb.append("Fx= " + Fkt.nf(Fx, 1));
sb.append(", Fy= " + Fkt.nf(Fy, 1));
sb.append(", |F|= " + Fkt.nf(f(), 1) + "kN ");
sb.append(", x=" + Fkt.nf(x0, 3, 3));
sb.append(", y=" + Fkt.nf(y0, 3, 3));
String text = sb.toString();
return text;
}
/** Test*/
public static void main(String[] args) {
double Fx = 0;
double Fy = -100;
double x0 = 4;
double y0 = 10;
clKraft F = new clKraft(Fx, Fy, x0, y0);
double xA = 1;
double yA = 1;
double xB = 2;
double yB = 3;
double[] schnittpunkt = new double[2];
boolean geschnitten = F.getAngriffspktAufLinie(xA, yA, xB, yB, schnittpunkt);
if (!geschnitten) System.out.println("Kein Schnittpunkt!");
else {
System.out.println("x = " + Fkt.nf(schnittpunkt[0], 3));
System.out.println("y = " + Fkt.nf(schnittpunkt[1], 3));
}
}
}
Ads help maintain this website.