Dazu hatte ich nun die grundlegende Idee, ein Package einer WC einfach so aufzubauen, dass man förmlich einen Ordner hat, worin man die reine Component entwickelt und einen weiteren, wo man Docu-Snippets und auch Live-Demos oder sowas drin ablegen kann. Allgemein war meine Idee zu den Doku's so, dass man , um einen visuellen einheitlichen Stil zu gewährleisten, alle Informationen als *.md ( MarkDown ) Files schreibt.

Frage 1 wäre nun:
Wie würdet ihr die "einzelnen" Live-Demo-Beispiele bauen und zur Verfügung stellen?

Frage 1 wäre nun:

Dazu hatte ich nun die grundlegende Idee, ein Package einer WC einfach so aufzubauen, dass man förmlich einen Ordner hat, worin man die reine Component entwickelt und einen weiteren, wo man Docu-Snippets und auch Live-Demos oder sowas drin ablegen kann. Allgemein war meine Idee zu den Doku's so, dass man , um einen visuellen einheitlichen Stil zu gewährleisten, alle Informationen als *.md ( MarkDown ) Files schreibt.

Frage 1 wäre nun:
Wie würdet ihr die "einzelnen" Live-Demo-Beispiele bauen und zur Verfügung stellen?

Frage 2:
Wie könnte das Package des Living-Style-Guide aussehen bzw. wie könnte man die ganzen Informationen "möglichst" automatisiert so zusammen mergen, dass am Ende eine HTML bei raus kommt, die halt Infos zur Komponente gibt, wie auch Live-Demos zeigt etc......

hmm mit select ist es das gleich, eigentlich klar

wsA.Range("a1,b1").EntireColumn.Select

        Selection.ExportAsFixedFormat _

        Type:=xlTypePDF, _

        Filename:=myFile, _

Auch so wird jede Spalte auf einem extra Blatt ausgegeben

Ich hab auch eine Frage, vielleicht weiß ja jemand wie man das bequem löst.
Ich muss Elemente miteinander vergleichen und wenn ein Element mit allen bisherigen Elementen
der Liste mir ein 'unknown' liefert, dann ist das ein neues Element.
Wenn das NICHT so ist, hätte ich gern das label des bereits bekannten Elements.

Mir wurde geraten dafür ein Maybe Pattern (in TypeScript) zu verwenden aber so richtig werde ich daraus nicht schlau.
Naja hier erst mal mein Code:

function knownState(
  referenceList: UpgradedDecetionInterface[],
  currentElement: UpgradedDecetionInterface
): boolean {
  const newPerson = referenceList.every(referenceFace => {
    const bestMatch = referenceFace.faceMatcher.findBestMatch(
      currentElement.descriptor[0]
    );

    return bestMatch.label === 'unknown';
  });

  return newPerson;
}```
`newPerson` ist nur dann true, wenn das `every` bei jedem bisherigen Element 'unknown' ist, wie schon erwähnt.
Das Ding ist, wie komm ich jetzt am besten an das Label rann, ohne noch mal `findBestMatch` auszuführen?

Benutzen tue ich das bisher so:
```Javascript
const copyListOfDetections = listOfDetections;
let resultList: UpgradedDecetionInterface[] = [];

copyListOfDetections.map((detection, index) => {
    if (index >= 1) {
        const stateOfDetection = knownState(resultList, detection);

        if (stateOfDetection.known) {
            console.log('Kenn ich');
        } else {
            console.log('Kenn ich nicht');
            resultList.push(detection);
        }
    }
}```

Ich hab auch eine Frage, vielleicht weiß ja jemand wie man das bequem löst.
Ich muss Elemente miteinander vergleichen und wenn ein Element mit allen bisherigen Elementen
der Liste mir ein 'unknown' liefert, dann ist das ein neues Element.

Wenn das NICHT so ist, hätte ich gern das label des bereits bekannten Elements.

Mir wurde geraten dafür ein Maybe Pattern (in TypeScript) zu verwenden aber so richtig werde ich daraus nicht schlau.
Naja hier erst mal mein Code:

function knownState(
  referenceList: UpgradedDecetionInterface[],
  currentElement: UpgradedDecetionInterface
): boolean {
  const newPerson = referenceList.every(referenceFace => {
    const bestMatch = referenceFace.faceMatcher.findBestMatch(
      currentElement.descriptor[0]
    );

    return bestMatch.label === 'unknown';
  });

  return newPerson;
}

newPerson ist nur dann true, wenn das every bei jedem bisherigen Element 'unknown' ist, wie schon erwähnt.
Das Ding ist, wie komm ich jetzt am besten an das Label rann, ohne noch mal findBestMatch auszuführen?

Benutzen tue ich das bisher so:

const copyListOfDetections = listOfDetections;
let resultList: UpgradedDecetionInterface[] = [];

copyListOfDetections.map((detection, index) => {
    if (index >= 1) {
        const stateOfDetection = knownState(resultList, detection);

        if (stateOfDetection.known) {
            console.log('Kenn ich');
        } else {
            console.log('Kenn ich nicht');
            resultList.push(detection);
        }
    }
}```

Ich hab auch eine Frage, vielleicht weiß ja jemand wie man das bequem löst.
Ich muss Elemente miteinander vergleichen und wenn ein Element mit allen bisherigen Elementen
der Liste mir ein 'unknown' liefert, dann ist das ein neues Element.

Wenn das NICHT so ist, hätte ich gern das label des bereits bekannten Elements.

Mir wurde geraten dafür ein Maybe Pattern (in TypeScript) zu verwenden aber so richtig werde ich daraus nicht schlau.
Naja hier erst mal mein Code:

function knownState(
  referenceList: UpgradedDecetionInterface[],
  currentElement: UpgradedDecetionInterface
): boolean {
  const newPerson = referenceList.every(referenceFace => {
    const bestMatch = referenceFace.faceMatcher.findBestMatch(
      currentElement.descriptor[0]
    );

    return bestMatch.label === 'unknown';
  });

  return newPerson;
}

newPerson ist nur dann true, wenn das every bei jedem bisherigen Element 'unknown' ist, wie schon erwähnt.
Das Ding ist, wie komm ich jetzt am besten an das Label rann, ohne noch mal findBestMatch auszuführen?

Benutzen tue ich das bisher so:

const copyListOfDetections = listOfDetections;
let resultList: UpgradedDecetionInterface[] = [];

copyListOfDetections.map((detection, index) => {
    if (index >= 1) {
        const stateOfDetection = knownState(resultList, detection);

        if (stateOfDetection.known) {
            console.log('Kenn ich');
        } else {
            console.log('Kenn ich nicht');
            resultList.push(detection);
        }
    }
}

export class UnknownDetection {
    known: boolean = false;
}

export class KnownDetection {
    known: boolean = true;
    label: string;
    distance: number;
}

export type knownDetection = UnknownDetection | KnownDetection;

sah dann so aus:

function knownState(
    referenceFaces: UpgradedDecetionInterface[],
    currentDetection: UpgradedDecetionInterface,
): knownDetection {
    let knownPersonLabel: knownDetection = { known: false };

    const newPerson = referenceFaces.every(referenceFace => {
        const bestMatch = referenceFace.faceMatcher.findBestMatch(
            currentDetection.descriptor[0],
        );

        if (bestMatch.label !== 'unknown') {
            knownPersonLabel = {
                distance: bestMatch.distance,
                known: true,
                label: bestMatch.label,
            };
        }

        return bestMatch.label === 'unknown';
    });

    if (newPerson) {
        const unknownState = {
            known: false,
        };
        console.log(unknownState);

        return unknownState
    } else {
        console.log(knownPersonLabel);

        knownPersonLabel;
    }
}

tarvos90: sowas in der Richtung:

    let result: { label: knownDetection, newPerson: boolean } = {
        label: { known: false },
        newPerson: false,
    }

    const result = referenceFaces.reduce((prev, current) => {
        
    })

so geht's lol :D

function getKnownState(
    referenceFaces: UpgradedDecetionInterface[],
    currentDetection: UpgradedDecetionInterface,
): knownStateInterface {
    // Returns true if every referenceFace in referenceFaces
    // compared to one Detection is labeled as 'unknown'.
    const isNew = referenceFaces.every(referenceFace => {
        const bestMatch = referenceFace.faceMatcher.findBestMatch(
            currentDetection.descriptor[0],
        );

        return bestMatch.label === 'unknown';
    });

    if (isNew) {
        const newDetection = {
            known: false,
        };

        return newDetection;
    }

    const bestMatchLabels = referenceFaces.map(referenceFace => {
        const bestMatch = referenceFace.faceMatcher.findBestMatch(
            currentDetection.descriptor[0],
        );

        return bestMatch.toString(false);
    });

    const bestMatchLabel = bestMatchLabels.filter(label => {
        return label !== 'unknown';
    })[0];

    const knownDetection = {
        known: true,
        label: bestMatchLabel,
    };

    return knownDetection;
}

tarvos90: Würde das eher so machen:

    const bestMatchLabel = bestMatchLabels.filter(label => {
        return label !== 'unknown';
    }).shift();

Finde so Array-Access über index nicht so optimal, weil es ja nicht umbedingt gegeben sein muss das es das Element gibt.

Ich hab außerdem zur späten Stunde noch mal ein rxjs Anliegen :D, ich hab einen Stream von Daten einer Webcam und erkenne dort Gesichter mit einer API. Ich möchte jetzt alle erfassten Gesichter emitten (eine Liste/Array), wenn eine gewisse Zeitlang nichts erkannt wurde. Der Stream soll aber nicht enden, es soll dann eine neue Liste angefangen werden.

Mein erster Ansatz sieht so aus:

const detector = interval(intervalValue).pipe(
    exhaustMap(() => {
        return this.detectFaces();
    }),
    filter(x => x !== undefined),
    map(detections => {
        return detections.map(this.faceApiService.transformDetection);
    }),
    timeout(5000),
);

detectFaces gibt mir entweder eine Liste von Detections oder eben undefined, deswegen fand ich das mit filter und timeout eigentlich ganz gut so. Aber ist ja nun nicht ganz das was ich brauche.
Irgendwie denke ich, müsste ich bufferTime mit timeout kombinieren aber ich nicht wirklich Ahnung von rxja und hab mir das nur mit diesem decision tree zusammengebaut