def get_next_passes(self, utc_time, length, lon, lat, alt, tol=0.001, horizon=0):
        """Calculate passes for the next hours for a given start time and a
        given observer.

        Original by Martin.

        utc_time: Observation time (datetime object)
        length: Number of hours to find passes (int)
        lon: Longitude of observer position on ground (float)
        lat: Latitude of observer position on ground (float)
        alt: Altitude above sea-level (geoid) of observer position on ground (float)
        tol: precision of the result in seconds
        horizon: the elevation of horizon to compute risetime and falltime.

        Return: [(rise-time, fall-time, max-elevation-time), ...]
        """

        def elevation(minutes):
            """Compute the elevation."""
            return self.get_observer_look(utc_time +
                                          timedelta(
                                              minutes=np.float64(minutes)),
                                          lon, lat, alt)[1] - horizon

        def elevation_inv(minutes):
            """Compute the inverse of elevation."""
            return -elevation(minutes)

        def get_root(fun, start, end, tol=0.01):
            """Root finding scheme"""
            x_0 = end
            x_1 = start
            fx_0 = fun(end)
            fx_1 = fun(start)
            if abs(fx_0) < abs(fx_1):
                fx_0, fx_1 = fx_1, fx_0
                x_0, x_1 = x_1, x_0

            x_n = optimize.brentq(fun, x_0, x_1)
            return x_n

        def get_max_parab(fun, start, end, tol=0.01):
            """Successive parabolic interpolation."""
            a = float(start)
            c = float(end)
            b = (a + c) / 2.0

            f_a = fun(a)
            f_b = fun(b)
            f_c = fun(c)

            x = b

            while True:
                x = x - 0.5 * (((b - a) ** 2 * (f_b - f_c)
                                - (b - c) ** 2 * (f_b - f_a)) /
                               ((b - a) * (f_b - f_c) - (b - c) * (f_b - f_a)))
                if np.isnan(x):
                    return b
                if abs(b - x) <= tol:
                    return x

                a, b, c = (a + x) / 2.0, x, (x + c) / 2.0
                f_a, f_b, f_c = fun(a), fun(b), fun(c)

        # every minute
        times = utc_time + np.array([timedelta(minutes=minutes)
                                     for minutes in range(length * 60)])
        elev = self.get_observer_look(times, lon, lat, alt)[1] - horizon
        zcs = np.where(np.diff(np.sign(elev)))[0]
        res = []
        risetime = None
        falltime = None
        for guess in zcs:
            horizon_mins = get_root(
                elevation, guess, guess + 1.0, tol=tol / 60.0)
            horizon_time = utc_time + timedelta(minutes=horizon_mins)
            if elev[guess] < 0:
                risetime = horizon_time
                risemins = horizon_mins
                falltime = None
            else:
                falltime = horizon_time
                fallmins = horizon_mins
                if risetime:
                    int_start = max(0, int(np.floor(risemins)))
                    int_end = min(len(elev), int(np.ceil(fallmins) + 1))
                    middle = int_start + np.argmax(elev[int_start:int_end])
                    highest = utc_time + \
                        timedelta(minutes=get_max_parab(
                            elevation_inv,
                            max(risemins, middle - 1), min(fallmins, middle + 1),
                            tol=tol / 60.0
                        ))
                    res += [(risetime, falltime, highest)]
                risetime = None
        return res