def _process_mrk_marker_view(self, limit):
        """
        This is the definition of markers
        (as in genes, but other genomic loci types as well).
        It looks up the identifiers in the hashmap
        This includes their labels, specific class, and identifiers
        TODO should we use the mrk_mouse_view instead?

        Triples:
        <marker_id> a owl:Class OR owl:NamedIndividual
            GENO:marker_type
            rdf:label <symbol>
            RO:in_taxon <NCBITaxon_id>

        :param limit:
        :return:
        """
        if self.test_mode:
            graph = self.testgraph
        else:
            graph = self.graph
        model = Model(graph)
        geno = Genotype(graph)
        line_counter = 0
        raw = '/'.join((self.rawdir, 'mrk_marker_view'))
        LOG.info("getting markers and assigning types")
        with open(raw, 'r') as f:
            f.readline()  # read the header row; skip
            for line in f:
                line = line.rstrip("\n")
                line_counter += 1

                (marker_key, organism_key, marker_status_key,
                 symbol, name, latin_name, marker_type) = line.split('\t')

                if self.test_mode is True:
                    if int(marker_key) not in self.test_keys.get('marker'):
                        continue

                # use only non-withdrawn markers
                if marker_status_key != '2':
                    marker_id = self.idhash['marker'].get(marker_key)

                    # only pull info for mouse genes for now
                    # other species should come from other dbs
                    if organism_key != '1':
                        continue

                    if marker_id is None:
                        LOG.error(
                            "can't find %s %s in the id hash", marker_key, symbol)

                    mapped_marker_type = self.resolve(marker_type.strip())

                    # if it's unlocated, or is not a gene,
                    # then don't add it as a class because
                    # it's not added as a gene.
                    # everything except for genes are modeled as individuals

                    if mapped_marker_type in [
                            self.globaltt['gene'],
                            self.globaltt['pseudogene']]:
                        model.addClassToGraph(
                            marker_id, symbol, mapped_marker_type, name)
                        model.addSynonym(
                            marker_id, name, self.globaltt['has_exact_synonym'])
                        self.markers['classes'].append(marker_id)
                    else:
                        model.addIndividualToGraph(
                            marker_id, symbol, mapped_marker_type, name)
                        model.addSynonym(
                            marker_id, name, self.globaltt['has_exact_synonym'])
                        self.markers['indiv'].append(marker_id)

                    self.label_hash[marker_id] = symbol
                    # add the taxon
                    taxon_id = self.resolve(latin_name)  # not always proper binomial
                    geno.addTaxon(taxon_id, marker_id)

                    # make MGI the leader for mouse genes.
                    if taxon_id == self.globaltt['Mus musculus']:
                        model.makeLeader(marker_id)

                    if not self.test_mode and limit is not None and line_counter > limit:
                        break

        return