docs: def addFeatureToGraph(
              self, add_region=True, region_id=None, feature_as_class=False):
          """
          We make the assumption here that all features are instances.
          The features are located on a region,
          which begins and ends with faldo:Position
          The feature locations leverage the Faldo model,
          which has a general structure like:
          Triples:
          feature_id a feature_type (individual)
          faldo:location region_id
          region_id a faldo:region
          faldo:begin start_position
          faldo:end end_position
          start_position a
          (any of: faldo:(((Both|Plus|Minus)Strand)|Exact)Position)
          faldo:position Integer(numeric position)
          faldo:reference reference_id
          end_position a
          (any of: faldo:(((Both|Plus|Minus)Strand)|Exact)Position)
          faldo:position Integer(numeric position)
          faldo:reference reference_id
  
          :param graph:
  
          :return:
  
          """
  
          if feature_as_class:
              self.model.addClassToGraph(
                  self.fid, self.label, self.ftype, self.description)
          else:
              self.model.addIndividualToGraph(
                  self.fid, self.label, self.ftype, self.description)
  
          if self.start is None and self.stop is None:
              add_region = False
  
          if add_region:
              # create a region that has the begin/end positions
              regionchr = re.sub(r'\w+\:_?', '', self.start['reference'])
              if region_id is None:
                  # in case the values are undefined
                  # if we know only one of the coordinates,
                  # then we'll add an "unknown" other.
                  st = sp = 'UN'
                  strand = None
                  if self.start is not None and self.start['coordinate'] is not None:
                      st = str(self.start['coordinate'])
                      strand = self._getStrandStringFromPositionTypes(self.start['type'])
                  if self.stop is not None and self.stop['coordinate'] is not None:
                      sp = str(self.stop['coordinate'])
                      if strand is not None:
                          strand = self._getStrandStringFromPositionTypes(
                              self.stop['type'])
                  # assume that the strand is the same for both start and stop.
                  # this will need to be fixed in the future
                  region_items = [regionchr, st, sp]
                  if strand is not None:
                      region_items += [strand]
                  region_id = '-'.join(region_items)
                  rid = region_id
                  rid = re.sub(r'\w+\:', '', rid, 1)  # replace the id prefix
                  rid = '_:'+rid+"-Region"
                  region_id = rid
  
              self.graph.addTriple(self.fid, self.globaltt['location'], region_id)
              self.model.addIndividualToGraph(region_id, None, self.globaltt['Region'])
          else:
              region_id = self.fid
              self.model.addType(region_id, self.globaltt['region'])
  
          # add the start/end positions to the region
          beginp = endp = None
          if self.start is not None:
              beginp = self._makePositionId(
                  self.start['reference'], self.start['coordinate'], self.start['type'])
              self.addPositionToGraph(
                  self.start['reference'], self.start['coordinate'], self.start['type'])
  
          if self.stop is not None:
              endp = self._makePositionId(
                  self.stop['reference'], self.stop['coordinate'], self.stop['type'])
              self.addPositionToGraph(
                  self.stop['reference'], self.stop['coordinate'], self.stop['type'])
  
          self.addRegionPositionToGraph(region_id, beginp, endp)
  
          # {coordinate : integer, reference : reference_id, types = []}
  
          return