Frage:
Wie kann ich FCS-Dateien mit Open Source-Bibliotheken lesen?
WYSIWYG
2017-06-30 15:37:39 UTC
view on stackexchange narkive permalink

FCS ist ein patentiertes Datenformat zum Speichern von Durchflusszytometriedaten. Die neueste Version ist FCS3.1. Es gibt einige Dokumentationen zum Format, aber keine Informationen zum Lesen dieser Dateien. Es gibt einige R-Pakete und einen MATLAB-Code zum Lesen einer FCS-Datei, aber ich suche nach Standardbibliotheken, die entweder vom FCS-Konsortium oder einer anderen Gruppe entwickelt wurden. Ich möchte auch wissen, ob FCS eine Teilmenge eines vorhandenen Standarddatenformats ist, das von einer Standardbibliothek mit einer beliebigen Programmiersprache gelesen werden kann.

Schließlich möchte ich diese Dateien in ein leicht lesbares Format konvertieren wie HDF5.

Ich finde es seltsam, dass Sie nach Standardbibliotheken fragen, aber die vorhandenen Standardtools ausschließen.
@Llopis das OP lehnt Standardwerkzeuge nicht ab, im Gegenteil, er sucht nach Standardbibliotheken.
@terdon Ich bin mir nicht sicher, wie Standardbibliotheken entschieden werden, aber ein R / Bioconductor-Paket oder ein MATLAB-Paket scheint mir ziemlich Standard zu sein (außer wenn das FCS-Konsortium natürlich eines anbietet).
@Llopis Standardmäßig gibt es eine betriebssystem- / sprachunabhängige Schnittstelle, über die diese Dateien gelesen werden können. Noch wichtiger ist, dass ich wissen möchte, wie FCS-Dateien von jeder allgemeinen Sprache gelesen werden können. Zu diesem Zweck erwarte ich so etwas wie einen Pseudocode.
Ich bin mir immer noch nicht sicher, was Sie wollen: Die Dokumentation, auf die Sie verlinken, kommt einem allgemeinen Pseudocode so nahe wie möglich: Sie enthält eine detaillierte, präzise Spezifikation des Formats. Dies sind die gleichen Informationen, die ein Pseudocode vermitteln würde, und es ist die herkömmliche Art und Weise, wie Datenformate beschrieben werden (Pseudocode wird hierfür praktisch nie verwendet). Dies sollte zusätzlich zur Existenz von Bibliotheken für gängige Analysesprachen (R, Python, Matlab) ausreichen, um mit dem Format zu arbeiten.
@WYSIWYG Zusätzlich zu den Aussagen von Konrad ist der flowCore in Bioconductor für Windows, iOS und Linux verfügbar.
@KonradRudolph Was ich möchte, ist eine Anweisung, wie diese Dateien gelesen werden sollen. Die Dokumentation beschreibt das Format, aber ich konnte die allgemeine Vorgehensweise zum Lesen des Formats nicht herausfinden, was ich mit Pseudocode gemeint habe. Nehmen Sie einfach an, dass ich keinen Bioleiter verwenden möchte. Nehmen wir an, ich möchte diese Dateien in C lesen. Wie soll ich vorgehen? Verwenden die FACS-Maschinen einen Standardmechanismus / eine Standardbibliothek zum Lesen / Schreiben von FCS-Dateien oder verwenden sie ihre eigenen Codes? Ich ging davon aus, dass ein von einem Konsortium definiertes Format eine Standardschnittstelle für den rw-Betrieb bereitgestellt hätte.
Warum ist .fcs ein patentiertes Format? Der Haftungsausschluss in der verlinkten Dokumentation besagt lediglich: "Es wird auf die Möglichkeit hingewiesen, dass die Implementierung dieses Standards möglicherweise die Verwendung von Gegenständen erfordert, die unter Patentrechte fallen." Es ist möglicherweise nicht einmal möglich, ihn zu patentieren, siehe: https: // Patente. stackexchange.com/questions/11968/can-patents-on-computer-file-formats-be-obtained
Drei antworten:
#1
+5
bli
2017-06-30 17:51:15 UTC
view on stackexchange narkive permalink

Vor einigen Jahren habe ich ein Python-Skript geschrieben, um FCS-Dateien in ein durch Tabulatoren getrenntes Format zu konvertieren. Es war weit davon entfernt, alle Möglichkeiten zu nutzen, die die Formatbeschreibung bietet, aber es funktionierte zumindest für einige der Dateien, die auf einem unserer Computer erstellt wurden: http://www.igh.cnrs.fr/equip/Seitz/ en_equipe-programmes.html

Die Formatdokumentation, die ich gefunden habe, hat die Dekodierung aktiviert (siehe Abschnitt 3 des von Ihnen erwähnten PDFs), erfordert jedoch das Lesen von Daten im Binärmodus.

Die allgemeine Idee dieses Formats (und ich denke, viele andere Binärformate) ist, dass es am Anfang der Datei eine Headerzone mit einer definierten Anzahl von Feldern gibt, die Zahlen codieren, die angeben, wie der Rest der Datei strukturiert ist. Eine erste Phase besteht darin, diesen Header gemäß der Beschreibung in der Dokumentation des Formats zu analysieren. Die aus dem Header extrahierten Informationen geben an, wo die Daten zu finden sind und wie sie codiert werden, und zwar gemäß den in der Formatdokumentation beschriebenen Regeln.

Falls dies nützlich sein kann und für den Datensatz, hier ist die Code aus dem oben genannten Skript (nachdem Kommentare entfernt wurden, von denen einige lediglich aus der Formatdokumentation kopiert wurden, und einige hinzugefügt wurden):

  #! / usr / bin / env python "" "Dieses Skript versucht, FCS-Durchflusszytometriedaten zu lesen. Formatanalyse, inspiriert von Informationen, die hier zu finden sind: http: //isac-net.org/Resources-for-Cytometrists/Data-Standards/ Data-File-Standards / Durchflusszytometrie-Data-File-Format-Standards.aspx "" import re # So dekodieren Sie binär codierte Datenimport-Strukturimport-Systemklasse Parameter (Objekt): "" Dieses Objekt repräsentiert einen der Parametertypen, die sind in einem DATA-Segment einer FCS-Datei vorhanden. "" __slots__ = ("p_name", "p_bits", "p_range", "p_ampl", "parser") def __init __ (self, p_name, p_bits, p_range, p_am pl): self.p_name = p_name self.p_bits = p_bits self.p_range = p_range self.p_ampl = p_ampl
# Funktion zum Parsen eines Parameters im Datensegment self.parser = Keine ################################## ################ Hier beginnt das Parsen des Header-Teils ##, der angibt, wo sich die anderen Teile befinden. ################################################# f = offen (sys.argv [1], "rb") # Der Formatname wird in 6 Buchstaben codiert. # Ein ASCII-Buchstabe wird mit einem octetfile_format = "" .join ([f.read (1) für __ in range (6)) codiert. ]) sys.stdout.write ("Format:% s \ n"% file_format) # Die Formatbeschreibungen reservieren 4 Oktette, die wir überspringen = f.read (4) # 8 Oktettblöcke codieren die Start- und Endpositionen # verschiedener Teile des datatext_start = int (f.read (8) .strip ("")) text_end = int (f.read (8) .strip ("")) data_start = int (f.read (8) .strip (" ")) data_end = int (f.read (8) .strip (" ")) analysis_start = int (f.read (8) .strip (" ")) analysis_end = int (f.read (8) .strip ( "")) if (analysis_start und analysis_end): sys.stderr.write ("Kann das ANALYSIS-Segment einer FCS-Datei nicht verarbeiten. \ n") ################### ##################################### Hier beginnt das Parsen des "TEXT" -Teils ##, der beschreibt, wie Die eigentlichen Daten sind organisiert ################################################ ######## f.seek (text_start) # Das erste Zeichen im primären TEXT-Segment ist das ASCII-Trennzeichen Zeichen.sep = f.read (1), wenn sep nicht in ["_", "@"]: alt_sep = "_ @ _" elif sep nicht in ["_", " | "]: alt_sep =" _ | _ "else: sep nicht in [" + "," | "] bestätigen alt_sep =" + | + "text_segment = f.read (text_end - text_start) fields = text_segment.split (sep ) info = {} i = 0, während i < len ​​(Felder) - 1: Schlüssel = Felder [i] i + = 1 Wert = Felder [i] i + = 1 # Bei Schlüsselwörtern wird die Groß- und Kleinschreibung nicht berücksichtigt. Sie können in eine Datei geschrieben werden in Kleinbuchstaben, Großbuchstaben oder einer # Mischung aus beiden. Ein FCS-Dateireader muss jedoch die Groß- und Kleinschreibung ignorieren. Ein Schlüsselwortwert kann # in Kleinbuchstaben, Großbuchstaben oder eine Mischung aus beiden sein. Bei Schlüsselwortwerten wird zwischen Groß- und Kleinschreibung unterschieden. info [key.upper ()] = val
print "% s Ereignisse wurden erkannt." % info ["$ TOT"] print "Jedes Ereignis ist durch% s Parameter gekennzeichnet."% info ["$ PAR"] if info ["$ NEXTDATA"]! = "0": sys.stderr.write ("Some other" Daten sind in der Datei vorhanden, wurden jedoch nicht analysiert. \ n ") # L - Listenmodus. Für jedes Ereignis wird der Wert jedes Parameters in der Reihenfolge gespeichert, in der die # -Parameter beschrieben werden. Die Anzahl der für Parameter 1 reservierten Bits wird mit dem Schlüsselwort # $ P1B beschrieben. Es kann nur einen Satz von Listenmodusdaten pro Datensatz geben. Das Schlüsselwort $ DATATYPE # beschreibt das Datenformat. Dies ist der vielseitigste Modus für die Speicherung von Durchflusszytometriedaten, da Daten für Modus C und Modus U aus den Daten des Modus L erstellt werden können. Info info ["$ MODE"] == "L" -Parameter = [] # Indizes der parametersp_indices = Bereich (1, int (info ["$ PAR"]) + 1) für i in p_indices: p_name = info ["$ P% dN"% i] p_bits = info ["$ P% dB"% i] p_range = info ["$ P% dR"% i] p_ampl = info ["$ P% dE"% i] parameters.append (Parameter (p_name, p_bits, p_range, p_ampl)) sys.stdout.write ("Die Parameter sind: \ n% s \ n "%" \ t ".join ([par.p_name für par in Parametern])) # Wie werden 32-Bit-Wörter organisiert, wenn info [" $ BYTEORD "] ==" 4,3,2 , 1 ": endianness =" > "else: endianness =" < "assert info [" $ BYTEORD "] ==" 1,2,3,4 "# Ich habe einen langen Kommentar entfernt, der nur eine Kopie der Dokumentation ist # Datentyp: if info ["$ DATATYPE"] == "I": für Par in Parametern: nb_bits = int (par.p_bits) assert nb_bits% 8 == 0 nb_bytes = nb_bits / 8 # Bestimmen Sie die Formatzeichenfolge für das Entpacken ng (siehe https://docs.python.org/2/library/struct.html) if nb_bytes == 1: c_type = "B" # unsigned char elif nb_bytes == 2: c_type = "H" # unsigned short elif nb_bytes == 4: c_type = "L" # unsigned long elif nb_bytes == 8: c_type = "Q" # unsigned long long else:
erhöhen Sie ValueError, "Anzahl der Bytes (% d), die für eine Ganzzahl nicht gültig sind (siehe https://docs.python.org/2/library/struct.html#byte-order-size-and-alignment)." % nb_bytes fmt = "% s% s"% (Endianness, c_type) p_range = int (par.p_range) def Parser (Daten): value = struct.unpack (fmt, data.read (nb_bytes)) [0] try: assert value < p_range außer AssertionError: print "Wert% s höher als% d"% (str (Wert), p_range) Rückgabewert par.parser = parser passelse: erhöhe NotImplementedError, "Bisher wurde nur das Parsen des ganzzahligen Werts implementiert . "out_file = open (sys.argv [2]," w ") out_file.write (" # amplification_types \ t "+" \ t ".join ([par.p_ampl für par in parameter]) +" \ n " ) out_file.write ("parameters \ t" + "\ t" .join ([par.p_name für par in parameters]) + "\ n") i = 1 ############# #################################### Hier beginnt das Parsen der eigentlichen Daten ######## ####################################### f.seek (data_start) während f.tell ( ) < data_end: values ​​= [] für par in parameters: values.append (par.parser (f)) out_f ile.write ("% d \ t"% i + "\ t" .join (map (str, values)) + "\ n") i + = 1out_file.close () f.close ()  
Die allgemeine Idee dieses Formats (und ich denke, viele andere Binärformate) ist, dass es am Anfang der Datei eine Headerzone mit einer definierten Anzahl von Feldern gibt, die Zahlen codieren, die angeben, wie der Rest der Datei strukturiert ist. Daher beginne ich mit dem Parsen dieses Headers gemäß der Beschreibung in der Dokumentation des Formats. Die aus dem Header extrahierten Informationen geben Auskunft darüber, wo sich die Daten befinden und wie sie codiert sind, und zwar gemäß den in der Formatdokumentation beschriebenen Regeln. Ich kann keinen Pseudocode schreiben, aber ich kann versuchen, Kommentare in den Python-Code einzufügen.
#2
+4
Fiver
2019-02-03 08:49:29 UTC
view on stackexchange narkive permalink

Ich verwalte mehrere Python-Bibliotheken für die Interaktion mit Durchflusszytometriedaten (FCS-Dateien). Das neueste davon, FlowKit, bietet Funktionen zum Exportieren der Ereignisdaten als NumPy-Array, Pandas DataFrame oder CSV-Text. Mit der Bibliothek h5py ist es trivial, als HDF5-Datei zu exportieren

#3
+3
gringer
2017-06-30 16:56:45 UTC
view on stackexchange narkive permalink

R / Bioconductor verfügt über eine Reihe verschiedener Durchflusszytometrie-Verarbeitungspakete. Ein Ausgangspunkt für die Betrachtung von Zytometriedaten von einem hohen Niveau aus wäre openCyto (oder seine Vignette), eine große Reihe von Werkzeugen für die grundlegende Extraktion und Analyse von FCS Dateien.

Ich habe in der Vergangenheit die FCS-Dateien als R-Struktur mit flowCore betrachtet. Das Laden einer einzelnen FCS-Datei ist recht einfach und folgt einem bekannten R-Muster:

  Dateiname <- "/dir/file.fcs"x <- read.FCS (Dateiname, Transformation = FALSE) Zusammenfassung (x)  

Die Frage nach der Konvertierung von FCS-Dateien in ein "leicht lesbares Format wie HDF5" scheint nicht die richtige Frage zu sein. HDF5 ist ein Containerformat und weist eine große Ähnlichkeit mit Dateisystemen auf. Ich habe festgestellt, dass es am besten ist, FCS-Dateien so zu belassen, wie sie sind, da es sich um ein kompaktes, standardisiertes Binärformat handelt.

HDF5 ist kein großes Problem (ich mag es einfach). Ich bin immer noch gespannt, wie so etwas wie "read.FCS" funktioniert. Ich glaube, wenn FCS ein Standardformat ist, sollte es Standardbibliotheken (nicht proprietäre Bibliotheken) zum Lesen / Schreiben von FCS-Dateien geben. Ab sofort bin ich gezwungen, R oder Matlab zu verwenden (und es gibt auch hier keine Standardbibliotheken. Ich denke, es gibt nur verschiedene Pakete / Programme, die von verschiedenen Gruppen / Einzelpersonen erstellt wurden; kein einziger Standard). Was ist, wenn ich eine FCS-Datei auf C, Fortran oder Python (usw.) analysieren möchte?


Diese Fragen und Antworten wurden automatisch aus der englischen Sprache übersetzt.Der ursprüngliche Inhalt ist auf stackexchange verfügbar. Wir danken ihm für die cc by-sa 3.0-Lizenz, unter der er vertrieben wird.
Loading...